winsup/cygwin/devices.cc

   1
   2
   3 #include "winsup.h"
   4 #include <sys/types.h>
   5 #include <stdlib.h>
   6 #include <ctype.h>
   7 #include <string.h>
   8 #include "devices.h"
   9 #include "sys/cygwin.h"
  10 #include "tty.h"
  11 #include "pinfo.h"
  12 typedef const device *KR_device_t;
  13
  14
  15 static KR_device_t KR_find_keyword (const char *KR_keyword, int KR_length);
  16
  17
  18
  19 const device dev_cygdrive_storage =
  20   {"/cygdrive", FH_CYGDRIVE, "/cygdrive"};
  21
  22 const device dev_fs_storage =
  23   {"", FH_FS, ""};
  24
  25 const device dev_proc_storage =
  26   {"", FH_PROC, ""};
  27
  28 const device dev_registry_storage =
  29   {"", FH_REGISTRY, ""};
  30
  31 const device dev_piper_storage =
  32   {"", FH_PIPER, ""};
  33
  34 const device dev_pipew_storage =
  35   {"", FH_PIPEW, ""};
  36
  37 const device dev_tcp_storage =
  38   {"", FH_TCP, ""};
  39
  40 const device dev_udp_storage =
  41   {"", FH_UDP, ""};
  42
  43 const device dev_stream_storage =
  44   {"", FH_STREAM, ""};
  45
  46 const device dev_dgram_storage =
  47   {"", FH_DGRAM, ""};
  48
  49 const device dev_bad_storage =
  50   {"", FH_BAD, ""};
  51
  52 static const device dev_storage[] =
  53 {
  54   {"/dev/clipboard", FH_CLIPBOARD, "\\dev\\clipboard"},
  55   {"/dev/com1", FHDEV(DEV_SERIAL_MAJOR, 1), "\\\\.\\com1"},
  56   {"/dev/com2", FHDEV(DEV_SERIAL_MAJOR, 2), "\\\\.\\com2"},
  57   {"/dev/com3", FHDEV(DEV_SERIAL_MAJOR, 3), "\\\\.\\com3"},
  58   {"/dev/com4", FHDEV(DEV_SERIAL_MAJOR, 4), "\\\\.\\com4"},
  59   {"/dev/com5", FHDEV(DEV_SERIAL_MAJOR, 5), "\\\\.\\com5"},
  60   {"/dev/com6", FHDEV(DEV_SERIAL_MAJOR, 6), "\\\\.\\com6"},
  61   {"/dev/com7", FHDEV(DEV_SERIAL_MAJOR, 7), "\\\\.\\com7"},
  62   {"/dev/com8", FHDEV(DEV_SERIAL_MAJOR, 8), "\\\\.\\com8"},
  63   {"/dev/com9", FHDEV(DEV_SERIAL_MAJOR, 9), "\\\\.\\com9"},
  64   {"/dev/com10", FHDEV(DEV_SERIAL_MAJOR, 10), "\\\\.\\com10"},
  65   {"/dev/com11", FHDEV(DEV_SERIAL_MAJOR, 11), "\\\\.\\com11"},
  66   {"/dev/com12", FHDEV(DEV_SERIAL_MAJOR, 12), "\\\\.\\com12"},
  67   {"/dev/com13", FHDEV(DEV_SERIAL_MAJOR, 13), "\\\\.\\com13"},
  68   {"/dev/com14", FHDEV(DEV_SERIAL_MAJOR, 14), "\\\\.\\com14"},
  69   {"/dev/com15", FHDEV(DEV_SERIAL_MAJOR, 15), "\\\\.\\com15"},
  70   {"/dev/com16", FHDEV(DEV_SERIAL_MAJOR, 16), "\\\\.\\com16"},
  71   {"/dev/conin", FH_CONIN, "conin"},
  72   {"/dev/conout", FH_CONOUT, "conout"},
  73   {"/dev/console", FH_CONSOLE, "\\dev\\console"},
  74   {"/dev/dsp", FH_OSS_DSP, "\\dev\\dsp"},
  75   {"/dev/fd0", FHDEV(DEV_FLOPPY_MAJOR, 0), "\\Device\\Floppy0"},
  76   {"/dev/fd1", FHDEV(DEV_FLOPPY_MAJOR, 1), "\\Device\\Floppy1"},
  77   {"/dev/fd2", FHDEV(DEV_FLOPPY_MAJOR, 2), "\\Device\\Floppy2"},
  78   {"/dev/fd3", FHDEV(DEV_FLOPPY_MAJOR, 3), "\\Device\\Floppy3"},
  79   {"/dev/fd4", FHDEV(DEV_FLOPPY_MAJOR, 4), "\\Device\\Floppy4"},
  80   {"/dev/fd5", FHDEV(DEV_FLOPPY_MAJOR, 5), "\\Device\\Floppy5"},
  81   {"/dev/fd6", FHDEV(DEV_FLOPPY_MAJOR, 6), "\\Device\\Floppy6"},
  82   {"/dev/fd7", FHDEV(DEV_FLOPPY_MAJOR, 7), "\\Device\\Floppy7"},
  83   {"/dev/fd8", FHDEV(DEV_FLOPPY_MAJOR, 8), "\\Device\\Floppy8"},
  84   {"/dev/fd9", FHDEV(DEV_FLOPPY_MAJOR, 9), "\\Device\\Floppy9"},
  85   {"/dev/fd10", FHDEV(DEV_FLOPPY_MAJOR, 10), "\\Device\\Floppy10"},
  86   {"/dev/fd11", FHDEV(DEV_FLOPPY_MAJOR, 11), "\\Device\\Floppy11"},
  87   {"/dev/fd12", FHDEV(DEV_FLOPPY_MAJOR, 12), "\\Device\\Floppy12"},
  88   {"/dev/fd13", FHDEV(DEV_FLOPPY_MAJOR, 13), "\\Device\\Floppy13"},
  89   {"/dev/fd14", FHDEV(DEV_FLOPPY_MAJOR, 14), "\\Device\\Floppy14"},
  90   {"/dev/fd15", FHDEV(DEV_FLOPPY_MAJOR, 15), "\\Device\\Floppy15"},
  91   {"/dev/fifo", FH_FIFO, "\\dev\\fifo"},
  92   {"/dev/kmem", FH_KMEM, "\\dev\\mem"},
  93   {"/dev/mem", FH_MEM, "\\dev\\mem"},
  94   {"/dev/nst0", FHDEV(DEV_TAPE_MAJOR, 128), "\\Device\\Tape0"},
  95   {"/dev/nst1", FHDEV(DEV_TAPE_MAJOR, 129), "\\Device\\Tape1"},
  96   {"/dev/nst2", FHDEV(DEV_TAPE_MAJOR, 130), "\\Device\\Tape2"},
  97   {"/dev/nst3", FHDEV(DEV_TAPE_MAJOR, 131), "\\Device\\Tape3"},
  98   {"/dev/nst4", FHDEV(DEV_TAPE_MAJOR, 132), "\\Device\\Tape4"},
  99   {"/dev/nst5", FHDEV(DEV_TAPE_MAJOR, 133), "\\Device\\Tape5"},
 100   {"/dev/nst6", FHDEV(DEV_TAPE_MAJOR, 134), "\\Device\\Tape6"},
 101   {"/dev/nst7", FHDEV(DEV_TAPE_MAJOR, 135), "\\Device\\Tape7"},
 102   {"/dev/nst8", FHDEV(DEV_TAPE_MAJOR, 136), "\\Device\\Tape8"},
 103   {"/dev/nst9", FHDEV(DEV_TAPE_MAJOR, 137), "\\Device\\Tape9"},
 104   {"/dev/nst10", FHDEV(DEV_TAPE_MAJOR, 138), "\\Device\\Tape10"},
 105   {"/dev/nst11", FHDEV(DEV_TAPE_MAJOR, 139), "\\Device\\Tape11"},
 106   {"/dev/nst12", FHDEV(DEV_TAPE_MAJOR, 140), "\\Device\\Tape12"},
 107   {"/dev/nst13", FHDEV(DEV_TAPE_MAJOR, 141), "\\Device\\Tape13"},
 108   {"/dev/nst14", FHDEV(DEV_TAPE_MAJOR, 142), "\\Device\\Tape14"},
 109   {"/dev/nst15", FHDEV(DEV_TAPE_MAJOR, 143), "\\Device\\Tape15"},
 110   {"/dev/nst16", FHDEV(DEV_TAPE_MAJOR, 144), "\\Device\\Tape16"},
 111   {"/dev/nst17", FHDEV(DEV_TAPE_MAJOR, 145), "\\Device\\Tape17"},
 112   {"/dev/nst18", FHDEV(DEV_TAPE_MAJOR, 146), "\\Device\\Tape18"},
 113   {"/dev/nst19", FHDEV(DEV_TAPE_MAJOR, 147), "\\Device\\Tape19"},
 114   {"/dev/nst20", FHDEV(DEV_TAPE_MAJOR, 148), "\\Device\\Tape20"},
 115   {"/dev/nst21", FHDEV(DEV_TAPE_MAJOR, 149), "\\Device\\Tape21"},
 116   {"/dev/nst22", FHDEV(DEV_TAPE_MAJOR, 150), "\\Device\\Tape22"},
 117   {"/dev/nst23", FHDEV(DEV_TAPE_MAJOR, 151), "\\Device\\Tape23"},
 118   {"/dev/nst24", FHDEV(DEV_TAPE_MAJOR, 152), "\\Device\\Tape24"},
 119   {"/dev/nst25", FHDEV(DEV_TAPE_MAJOR, 153), "\\Device\\Tape25"},
 120   {"/dev/nst26", FHDEV(DEV_TAPE_MAJOR, 154), "\\Device\\Tape26"},
 121   {"/dev/nst27", FHDEV(DEV_TAPE_MAJOR, 155), "\\Device\\Tape27"},
 122   {"/dev/nst28", FHDEV(DEV_TAPE_MAJOR, 156), "\\Device\\Tape28"},
 123   {"/dev/nst29", FHDEV(DEV_TAPE_MAJOR, 157), "\\Device\\Tape29"},
 124   {"/dev/nst30", FHDEV(DEV_TAPE_MAJOR, 158), "\\Device\\Tape30"},
 125   {"/dev/nst31", FHDEV(DEV_TAPE_MAJOR, 159), "\\Device\\Tape31"},
 126   {"/dev/nst32", FHDEV(DEV_TAPE_MAJOR, 160), "\\Device\\Tape32"},
 127   {"/dev/nst33", FHDEV(DEV_TAPE_MAJOR, 161), "\\Device\\Tape33"},
 128   {"/dev/nst34", FHDEV(DEV_TAPE_MAJOR, 162), "\\Device\\Tape34"},
 129   {"/dev/nst35", FHDEV(DEV_TAPE_MAJOR, 163), "\\Device\\Tape35"},
 130   {"/dev/nst36", FHDEV(DEV_TAPE_MAJOR, 164), "\\Device\\Tape36"},
 131   {"/dev/nst37", FHDEV(DEV_TAPE_MAJOR, 165), "\\Device\\Tape37"},
 132   {"/dev/nst38", FHDEV(DEV_TAPE_MAJOR, 166), "\\Device\\Tape38"},
 133   {"/dev/nst39", FHDEV(DEV_TAPE_MAJOR, 167), "\\Device\\Tape39"},
 134   {"/dev/nst40", FHDEV(DEV_TAPE_MAJOR, 168), "\\Device\\Tape40"},
 135   {"/dev/nst41", FHDEV(DEV_TAPE_MAJOR, 169), "\\Device\\Tape41"},
 136   {"/dev/nst42", FHDEV(DEV_TAPE_MAJOR, 170), "\\Device\\Tape42"},
 137   {"/dev/nst43", FHDEV(DEV_TAPE_MAJOR, 171), "\\Device\\Tape43"},
 138   {"/dev/nst44", FHDEV(DEV_TAPE_MAJOR, 172), "\\Device\\Tape44"},
 139   {"/dev/nst45", FHDEV(DEV_TAPE_MAJOR, 173), "\\Device\\Tape45"},
 140   {"/dev/nst46", FHDEV(DEV_TAPE_MAJOR, 174), "\\Device\\Tape46"},
 141   {"/dev/nst47", FHDEV(DEV_TAPE_MAJOR, 175), "\\Device\\Tape47"},
 142   {"/dev/nst48", FHDEV(DEV_TAPE_MAJOR, 176), "\\Device\\Tape48"},
 143   {"/dev/nst49", FHDEV(DEV_TAPE_MAJOR, 177), "\\Device\\Tape49"},
 144   {"/dev/nst50", FHDEV(DEV_TAPE_MAJOR, 178), "\\Device\\Tape50"},
 145   {"/dev/nst51", FHDEV(DEV_TAPE_MAJOR, 179), "\\Device\\Tape51"},
 146   {"/dev/nst52", FHDEV(DEV_TAPE_MAJOR, 180), "\\Device\\Tape52"},
 147   {"/dev/nst53", FHDEV(DEV_TAPE_MAJOR, 181), "\\Device\\Tape53"},
 148   {"/dev/nst54", FHDEV(DEV_TAPE_MAJOR, 182), "\\Device\\Tape54"},
 149   {"/dev/nst55", FHDEV(DEV_TAPE_MAJOR, 183), "\\Device\\Tape55"},
 150   {"/dev/nst56", FHDEV(DEV_TAPE_MAJOR, 184), "\\Device\\Tape56"},
 151   {"/dev/nst57", FHDEV(DEV_TAPE_MAJOR, 185), "\\Device\\Tape57"},
 152   {"/dev/nst58", FHDEV(DEV_TAPE_MAJOR, 186), "\\Device\\Tape58"},
 153   {"/dev/nst59", FHDEV(DEV_TAPE_MAJOR, 187), "\\Device\\Tape59"},
 154   {"/dev/nst60", FHDEV(DEV_TAPE_MAJOR, 188), "\\Device\\Tape60"},
 155   {"/dev/nst61", FHDEV(DEV_TAPE_MAJOR, 189), "\\Device\\Tape61"},
 156   {"/dev/nst62", FHDEV(DEV_TAPE_MAJOR, 190), "\\Device\\Tape62"},
 157   {"/dev/nst63", FHDEV(DEV_TAPE_MAJOR, 191), "\\Device\\Tape63"},
 158   {"/dev/nst64", FHDEV(DEV_TAPE_MAJOR, 192), "\\Device\\Tape64"},
 159   {"/dev/nst65", FHDEV(DEV_TAPE_MAJOR, 193), "\\Device\\Tape65"},
 160   {"/dev/nst66", FHDEV(DEV_TAPE_MAJOR, 194), "\\Device\\Tape66"},
 161   {"/dev/nst67", FHDEV(DEV_TAPE_MAJOR, 195), "\\Device\\Tape67"},
 162   {"/dev/nst68", FHDEV(DEV_TAPE_MAJOR, 196), "\\Device\\Tape68"},
 163   {"/dev/nst69", FHDEV(DEV_TAPE_MAJOR, 197), "\\Device\\Tape69"},
 164   {"/dev/nst70", FHDEV(DEV_TAPE_MAJOR, 198), "\\Device\\Tape70"},
 165   {"/dev/nst71", FHDEV(DEV_TAPE_MAJOR, 199), "\\Device\\Tape71"},
 166   {"/dev/nst72", FHDEV(DEV_TAPE_MAJOR, 200), "\\Device\\Tape72"},
 167   {"/dev/nst73", FHDEV(DEV_TAPE_MAJOR, 201), "\\Device\\Tape73"},
 168   {"/dev/nst74", FHDEV(DEV_TAPE_MAJOR, 202), "\\Device\\Tape74"},
 169   {"/dev/nst75", FHDEV(DEV_TAPE_MAJOR, 203), "\\Device\\Tape75"},
 170   {"/dev/nst76", FHDEV(DEV_TAPE_MAJOR, 204), "\\Device\\Tape76"},
 171   {"/dev/nst77", FHDEV(DEV_TAPE_MAJOR, 205), "\\Device\\Tape77"},
 172   {"/dev/nst78", FHDEV(DEV_TAPE_MAJOR, 206), "\\Device\\Tape78"},
 173   {"/dev/nst79", FHDEV(DEV_TAPE_MAJOR, 207), "\\Device\\Tape79"},
 174   {"/dev/nst80", FHDEV(DEV_TAPE_MAJOR, 208), "\\Device\\Tape80"},
 175   {"/dev/nst81", FHDEV(DEV_TAPE_MAJOR, 209), "\\Device\\Tape81"},
 176   {"/dev/nst82", FHDEV(DEV_TAPE_MAJOR, 210), "\\Device\\Tape82"},
 177   {"/dev/nst83", FHDEV(DEV_TAPE_MAJOR, 211), "\\Device\\Tape83"},
 178   {"/dev/nst84", FHDEV(DEV_TAPE_MAJOR, 212), "\\Device\\Tape84"},
 179   {"/dev/nst85", FHDEV(DEV_TAPE_MAJOR, 213), "\\Device\\Tape85"},
 180   {"/dev/nst86", FHDEV(DEV_TAPE_MAJOR, 214), "\\Device\\Tape86"},
 181   {"/dev/nst87", FHDEV(DEV_TAPE_MAJOR, 215), "\\Device\\Tape87"},
 182   {"/dev/nst88", FHDEV(DEV_TAPE_MAJOR, 216), "\\Device\\Tape88"},
 183   {"/dev/nst89", FHDEV(DEV_TAPE_MAJOR, 217), "\\Device\\Tape89"},
 184   {"/dev/nst90", FHDEV(DEV_TAPE_MAJOR, 218), "\\Device\\Tape90"},
 185   {"/dev/nst91", FHDEV(DEV_TAPE_MAJOR, 219), "\\Device\\Tape91"},
 186   {"/dev/nst92", FHDEV(DEV_TAPE_MAJOR, 220), "\\Device\\Tape92"},
 187   {"/dev/nst93", FHDEV(DEV_TAPE_MAJOR, 221), "\\Device\\Tape93"},
 188   {"/dev/nst94", FHDEV(DEV_TAPE_MAJOR, 222), "\\Device\\Tape94"},
 189   {"/dev/nst95", FHDEV(DEV_TAPE_MAJOR, 223), "\\Device\\Tape95"},
 190   {"/dev/nst96", FHDEV(DEV_TAPE_MAJOR, 224), "\\Device\\Tape96"},
 191   {"/dev/nst97", FHDEV(DEV_TAPE_MAJOR, 225), "\\Device\\Tape97"},
 192   {"/dev/nst98", FHDEV(DEV_TAPE_MAJOR, 226), "\\Device\\Tape98"},
 193   {"/dev/nst99", FHDEV(DEV_TAPE_MAJOR, 227), "\\Device\\Tape99"},
 194   {"/dev/nst100", FHDEV(DEV_TAPE_MAJOR, 228), "\\Device\\Tape100"},
 195   {"/dev/nst101", FHDEV(DEV_TAPE_MAJOR, 229), "\\Device\\Tape101"},
 196   {"/dev/nst102", FHDEV(DEV_TAPE_MAJOR, 230), "\\Device\\Tape102"},
 197   {"/dev/nst103", FHDEV(DEV_TAPE_MAJOR, 231), "\\Device\\Tape103"},
 198   {"/dev/nst104", FHDEV(DEV_TAPE_MAJOR, 232), "\\Device\\Tape104"},
 199   {"/dev/nst105", FHDEV(DEV_TAPE_MAJOR, 233), "\\Device\\Tape105"},
 200   {"/dev/nst106", FHDEV(DEV_TAPE_MAJOR, 234), "\\Device\\Tape106"},
 201   {"/dev/nst107", FHDEV(DEV_TAPE_MAJOR, 235), "\\Device\\Tape107"},
 202   {"/dev/nst108", FHDEV(DEV_TAPE_MAJOR, 236), "\\Device\\Tape108"},
 203   {"/dev/nst109", FHDEV(DEV_TAPE_MAJOR, 237), "\\Device\\Tape109"},
 204   {"/dev/nst110", FHDEV(DEV_TAPE_MAJOR, 238), "\\Device\\Tape110"},
 205   {"/dev/nst111", FHDEV(DEV_TAPE_MAJOR, 239), "\\Device\\Tape111"},
 206   {"/dev/nst112", FHDEV(DEV_TAPE_MAJOR, 240), "\\Device\\Tape112"},
 207   {"/dev/nst113", FHDEV(DEV_TAPE_MAJOR, 241), "\\Device\\Tape113"},
 208   {"/dev/nst114", FHDEV(DEV_TAPE_MAJOR, 242), "\\Device\\Tape114"},
 209   {"/dev/nst115", FHDEV(DEV_TAPE_MAJOR, 243), "\\Device\\Tape115"},
 210   {"/dev/nst116", FHDEV(DEV_TAPE_MAJOR, 244), "\\Device\\Tape116"},
 211   {"/dev/nst117", FHDEV(DEV_TAPE_MAJOR, 245), "\\Device\\Tape117"},
 212   {"/dev/nst118", FHDEV(DEV_TAPE_MAJOR, 246), "\\Device\\Tape118"},
 213   {"/dev/nst119", FHDEV(DEV_TAPE_MAJOR, 247), "\\Device\\Tape119"},
 214   {"/dev/nst120", FHDEV(DEV_TAPE_MAJOR, 248), "\\Device\\Tape120"},
 215   {"/dev/nst121", FHDEV(DEV_TAPE_MAJOR, 249), "\\Device\\Tape121"},
 216   {"/dev/nst122", FHDEV(DEV_TAPE_MAJOR, 250), "\\Device\\Tape122"},
 217   {"/dev/nst123", FHDEV(DEV_TAPE_MAJOR, 251), "\\Device\\Tape123"},
 218   {"/dev/nst124", FHDEV(DEV_TAPE_MAJOR, 252), "\\Device\\Tape124"},
 219   {"/dev/nst125", FHDEV(DEV_TAPE_MAJOR, 253), "\\Device\\Tape125"},
 220   {"/dev/nst126", FHDEV(DEV_TAPE_MAJOR, 254), "\\Device\\Tape126"},
 221   {"/dev/nst127", FHDEV(DEV_TAPE_MAJOR, 255), "\\Device\\Tape127"},
 222   {"/dev/null", FH_NULL, "nul"},
 223   {"/dev/pipe", FH_PIPE, "\\dev\\pipe"},
 224   {"/dev/port", FH_PORT, "\\dev\\port"},
 225   {"/dev/ptmx", FH_PTYM, "\\dev\\ptmx"},
 226   {"/dev/random", FH_RANDOM, "\\dev\\random"},
 227   {"/dev/scd0", FHDEV(DEV_CDROM_MAJOR, 0), "\\Device\\CdRom0"},
 228   {"/dev/scd1", FHDEV(DEV_CDROM_MAJOR, 1), "\\Device\\CdRom1"},
 229   {"/dev/scd2", FHDEV(DEV_CDROM_MAJOR, 2), "\\Device\\CdRom2"},
 230   {"/dev/scd3", FHDEV(DEV_CDROM_MAJOR, 3), "\\Device\\CdRom3"},
 231   {"/dev/scd4", FHDEV(DEV_CDROM_MAJOR, 4), "\\Device\\CdRom4"},
 232   {"/dev/scd5", FHDEV(DEV_CDROM_MAJOR, 5), "\\Device\\CdRom5"},
 233   {"/dev/scd6", FHDEV(DEV_CDROM_MAJOR, 6), "\\Device\\CdRom6"},
 234   {"/dev/scd7", FHDEV(DEV_CDROM_MAJOR, 7), "\\Device\\CdRom7"},
 235   {"/dev/scd8", FHDEV(DEV_CDROM_MAJOR, 8), "\\Device\\CdRom8"},
 236   {"/dev/scd9", FHDEV(DEV_CDROM_MAJOR, 9), "\\Device\\CdRom9"},
 237   {"/dev/scd10", FHDEV(DEV_CDROM_MAJOR, 10), "\\Device\\CdRom10"},
 238   {"/dev/scd11", FHDEV(DEV_CDROM_MAJOR, 11), "\\Device\\CdRom11"},
 239   {"/dev/scd12", FHDEV(DEV_CDROM_MAJOR, 12), "\\Device\\CdRom12"},
 240   {"/dev/scd13", FHDEV(DEV_CDROM_MAJOR, 13), "\\Device\\CdRom13"},
 241   {"/dev/scd14", FHDEV(DEV_CDROM_MAJOR, 14), "\\Device\\CdRom14"},
 242   {"/dev/scd15", FHDEV(DEV_CDROM_MAJOR, 15), "\\Device\\CdRom15"},
 243   {"/dev/sda", FH_SDA, "\\Device\\Harddisk0\\Partition0"},
 244   {"/dev/sdb", FH_SDB, "\\Device\\Harddisk1\\Partition0"},
 245   {"/dev/sdc", FH_SDC, "\\Device\\Harddisk2\\Partition0"},
 246   {"/dev/sdd", FH_SDD, "\\Device\\Harddisk3\\Partition0"},
 247   {"/dev/sde", FH_SDE, "\\Device\\Harddisk4\\Partition0"},
 248   {"/dev/sdf", FH_SDF, "\\Device\\Harddisk5\\Partition0"},
 249   {"/dev/sdg", FH_SDG, "\\Device\\Harddisk6\\Partition0"},
 250   {"/dev/sdh", FH_SDH, "\\Device\\Harddisk7\\Partition0"},
 251   {"/dev/sdi", FH_SDI, "\\Device\\Harddisk8\\Partition0"},
 252   {"/dev/sdj", FH_SDJ, "\\Device\\Harddisk9\\Partition0"},
 253   {"/dev/sdk", FH_SDK, "\\Device\\Harddisk10\\Partition0"},
 254   {"/dev/sdl", FH_SDL, "\\Device\\Harddisk11\\Partition0"},
 255   {"/dev/sdm", FH_SDM, "\\Device\\Harddisk12\\Partition0"},
 256   {"/dev/sdn", FH_SDN, "\\Device\\Harddisk13\\Partition0"},
 257   {"/dev/sdo", FH_SDO, "\\Device\\Harddisk14\\Partition0"},
 258   {"/dev/sdp", FH_SDP, "\\Device\\Harddisk15\\Partition0"},
 259   {"/dev/sdq", FH_SDQ, "\\Device\\Harddisk16\\Partition0"},
 260   {"/dev/sdr", FH_SDR, "\\Device\\Harddisk17\\Partition0"},
 261   {"/dev/sds", FH_SDS, "\\Device\\Harddisk18\\Partition0"},
 262   {"/dev/sdt", FH_SDT, "\\Device\\Harddisk19\\Partition0"},
 263   {"/dev/sdu", FH_SDU, "\\Device\\Harddisk20\\Partition0"},
 264   {"/dev/sdv", FH_SDV, "\\Device\\Harddisk21\\Partition0"},
 265   {"/dev/sdw", FH_SDW, "\\Device\\Harddisk22\\Partition0"},
 266   {"/dev/sdx", FH_SDX, "\\Device\\Harddisk23\\Partition0"},
 267   {"/dev/sdy", FH_SDY, "\\Device\\Harddisk24\\Partition0"},
 268   {"/dev/sdz", FH_SDZ, "\\Device\\Harddisk25\\Partition0"},
 269   {"/dev/sda1", FH_SDA | 1, "\\Device\\Harddisk0\\Partition1"},
 270   {"/dev/sda2", FH_SDA | 2, "\\Device\\Harddisk0\\Partition2"},
 271   {"/dev/sda3", FH_SDA | 3, "\\Device\\Harddisk0\\Partition3"},
 272   {"/dev/sda4", FH_SDA | 4, "\\Device\\Harddisk0\\Partition4"},
 273   {"/dev/sda5", FH_SDA | 5, "\\Device\\Harddisk0\\Partition5"},
 274   {"/dev/sda6", FH_SDA | 6, "\\Device\\Harddisk0\\Partition6"},
 275   {"/dev/sda7", FH_SDA | 7, "\\Device\\Harddisk0\\Partition7"},
 276   {"/dev/sda8", FH_SDA | 8, "\\Device\\Harddisk0\\Partition8"},
 277   {"/dev/sda9", FH_SDA | 9, "\\Device\\Harddisk0\\Partition9"},
 278   {"/dev/sda10", FH_SDA | 10, "\\Device\\Harddisk0\\Partition10"},
 279   {"/dev/sda11", FH_SDA | 11, "\\Device\\Harddisk0\\Partition11"},
 280   {"/dev/sda12", FH_SDA | 12, "\\Device\\Harddisk0\\Partition12"},
 281   {"/dev/sda13", FH_SDA | 13, "\\Device\\Harddisk0\\Partition13"},
 282   {"/dev/sda14", FH_SDA | 14, "\\Device\\Harddisk0\\Partition14"},
 283   {"/dev/sda15", FH_SDA | 15, "\\Device\\Harddisk0\\Partition15"},
 284   {"/dev/sdb1", FH_SDB | 1, "\\Device\\Harddisk1\\Partition1"},
 285   {"/dev/sdb2", FH_SDB | 2, "\\Device\\Harddisk1\\Partition2"},
 286   {"/dev/sdb3", FH_SDB | 3, "\\Device\\Harddisk1\\Partition3"},
 287   {"/dev/sdb4", FH_SDB | 4, "\\Device\\Harddisk1\\Partition4"},
 288   {"/dev/sdb5", FH_SDB | 5, "\\Device\\Harddisk1\\Partition5"},
 289   {"/dev/sdb6", FH_SDB | 6, "\\Device\\Harddisk1\\Partition6"},
 290   {"/dev/sdb7", FH_SDB | 7, "\\Device\\Harddisk1\\Partition7"},
 291   {"/dev/sdb8", FH_SDB | 8, "\\Device\\Harddisk1\\Partition8"},
 292   {"/dev/sdb9", FH_SDB | 9, "\\Device\\Harddisk1\\Partition9"},
 293   {"/dev/sdb10", FH_SDB | 10, "\\Device\\Harddisk1\\Partition10"},
 294   {"/dev/sdb11", FH_SDB | 11, "\\Device\\Harddisk1\\Partition11"},
 295   {"/dev/sdb12", FH_SDB | 12, "\\Device\\Harddisk1\\Partition12"},
 296   {"/dev/sdb13", FH_SDB | 13, "\\Device\\Harddisk1\\Partition13"},
 297   {"/dev/sdb14", FH_SDB | 14, "\\Device\\Harddisk1\\Partition14"},
 298   {"/dev/sdb15", FH_SDB | 15, "\\Device\\Harddisk1\\Partition15"},
 299   {"/dev/sdc1", FH_SDC | 1, "\\Device\\Harddisk2\\Partition1"},
 300   {"/dev/sdc2", FH_SDC | 2, "\\Device\\Harddisk2\\Partition2"},
 301   {"/dev/sdc3", FH_SDC | 3, "\\Device\\Harddisk2\\Partition3"},
 302   {"/dev/sdc4", FH_SDC | 4, "\\Device\\Harddisk2\\Partition4"},
 303   {"/dev/sdc5", FH_SDC | 5, "\\Device\\Harddisk2\\Partition5"},
 304   {"/dev/sdc6", FH_SDC | 6, "\\Device\\Harddisk2\\Partition6"},
 305   {"/dev/sdc7", FH_SDC | 7, "\\Device\\Harddisk2\\Partition7"},
 306   {"/dev/sdc8", FH_SDC | 8, "\\Device\\Harddisk2\\Partition8"},
 307   {"/dev/sdc9", FH_SDC | 9, "\\Device\\Harddisk2\\Partition9"},
 308   {"/dev/sdc10", FH_SDC | 10, "\\Device\\Harddisk2\\Partition10"},
 309   {"/dev/sdc11", FH_SDC | 11, "\\Device\\Harddisk2\\Partition11"},
 310   {"/dev/sdc12", FH_SDC | 12, "\\Device\\Harddisk2\\Partition12"},
 311   {"/dev/sdc13", FH_SDC | 13, "\\Device\\Harddisk2\\Partition13"},
 312   {"/dev/sdc14", FH_SDC | 14, "\\Device\\Harddisk2\\Partition14"},
 313   {"/dev/sdc15", FH_SDC | 15, "\\Device\\Harddisk2\\Partition15"},
 314   {"/dev/sdd1", FH_SDD | 1, "\\Device\\Harddisk3\\Partition1"},
 315   {"/dev/sdd2", FH_SDD | 2, "\\Device\\Harddisk3\\Partition2"},
 316   {"/dev/sdd3", FH_SDD | 3, "\\Device\\Harddisk3\\Partition3"},
 317   {"/dev/sdd4", FH_SDD | 4, "\\Device\\Harddisk3\\Partition4"},
 318   {"/dev/sdd5", FH_SDD | 5, "\\Device\\Harddisk3\\Partition5"},
 319   {"/dev/sdd6", FH_SDD | 6, "\\Device\\Harddisk3\\Partition6"},
 320   {"/dev/sdd7", FH_SDD | 7, "\\Device\\Harddisk3\\Partition7"},
 321   {"/dev/sdd8", FH_SDD | 8, "\\Device\\Harddisk3\\Partition8"},
 322   {"/dev/sdd9", FH_SDD | 9, "\\Device\\Harddisk3\\Partition9"},
 323   {"/dev/sdd10", FH_SDD | 10, "\\Device\\Harddisk3\\Partition10"},
 324   {"/dev/sdd11", FH_SDD | 11, "\\Device\\Harddisk3\\Partition11"},
 325   {"/dev/sdd12", FH_SDD | 12, "\\Device\\Harddisk3\\Partition12"},
 326   {"/dev/sdd13", FH_SDD | 13, "\\Device\\Harddisk3\\Partition13"},
 327   {"/dev/sdd14", FH_SDD | 14, "\\Device\\Harddisk3\\Partition14"},
 328   {"/dev/sdd15", FH_SDD | 15, "\\Device\\Harddisk3\\Partition15"},
 329   {"/dev/sde1", FH_SDE | 1, "\\Device\\Harddisk4\\Partition1"},
 330   {"/dev/sde2", FH_SDE | 2, "\\Device\\Harddisk4\\Partition2"},
 331   {"/dev/sde3", FH_SDE | 3, "\\Device\\Harddisk4\\Partition3"},
 332   {"/dev/sde4", FH_SDE | 4, "\\Device\\Harddisk4\\Partition4"},
 333   {"/dev/sde5", FH_SDE | 5, "\\Device\\Harddisk4\\Partition5"},
 334   {"/dev/sde6", FH_SDE | 6, "\\Device\\Harddisk4\\Partition6"},
 335   {"/dev/sde7", FH_SDE | 7, "\\Device\\Harddisk4\\Partition7"},
 336   {"/dev/sde8", FH_SDE | 8, "\\Device\\Harddisk4\\Partition8"},
 337   {"/dev/sde9", FH_SDE | 9, "\\Device\\Harddisk4\\Partition9"},
 338   {"/dev/sde10", FH_SDE | 10, "\\Device\\Harddisk4\\Partition10"},
 339   {"/dev/sde11", FH_SDE | 11, "\\Device\\Harddisk4\\Partition11"},
 340   {"/dev/sde12", FH_SDE | 12, "\\Device\\Harddisk4\\Partition12"},
 341   {"/dev/sde13", FH_SDE | 13, "\\Device\\Harddisk4\\Partition13"},
 342   {"/dev/sde14", FH_SDE | 14, "\\Device\\Harddisk4\\Partition14"},
 343   {"/dev/sde15", FH_SDE | 15, "\\Device\\Harddisk4\\Partition15"},
 344   {"/dev/sdf1", FH_SDF | 1, "\\Device\\Harddisk5\\Partition1"},
 345   {"/dev/sdf2", FH_SDF | 2, "\\Device\\Harddisk5\\Partition2"},
 346   {"/dev/sdf3", FH_SDF | 3, "\\Device\\Harddisk5\\Partition3"},
 347   {"/dev/sdf4", FH_SDF | 4, "\\Device\\Harddisk5\\Partition4"},
 348   {"/dev/sdf5", FH_SDF | 5, "\\Device\\Harddisk5\\Partition5"},
 349   {"/dev/sdf6", FH_SDF | 6, "\\Device\\Harddisk5\\Partition6"},
 350   {"/dev/sdf7", FH_SDF | 7, "\\Device\\Harddisk5\\Partition7"},
 351   {"/dev/sdf8", FH_SDF | 8, "\\Device\\Harddisk5\\Partition8"},
 352   {"/dev/sdf9", FH_SDF | 9, "\\Device\\Harddisk5\\Partition9"},
 353   {"/dev/sdf10", FH_SDF | 10, "\\Device\\Harddisk5\\Partition10"},
 354   {"/dev/sdf11", FH_SDF | 11, "\\Device\\Harddisk5\\Partition11"},
 355   {"/dev/sdf12", FH_SDF | 12, "\\Device\\Harddisk5\\Partition12"},
 356   {"/dev/sdf13", FH_SDF | 13, "\\Device\\Harddisk5\\Partition13"},
 357   {"/dev/sdf14", FH_SDF | 14, "\\Device\\Harddisk5\\Partition14"},
 358   {"/dev/sdf15", FH_SDF | 15, "\\Device\\Harddisk5\\Partition15"},
 359   {"/dev/sdg1", FH_SDG | 1, "\\Device\\Harddisk6\\Partition1"},
 360   {"/dev/sdg2", FH_SDG | 2, "\\Device\\Harddisk6\\Partition2"},
 361   {"/dev/sdg3", FH_SDG | 3, "\\Device\\Harddisk6\\Partition3"},
 362   {"/dev/sdg4", FH_SDG | 4, "\\Device\\Harddisk6\\Partition4"},
 363   {"/dev/sdg5", FH_SDG | 5, "\\Device\\Harddisk6\\Partition5"},
 364   {"/dev/sdg6", FH_SDG | 6, "\\Device\\Harddisk6\\Partition6"},
 365   {"/dev/sdg7", FH_SDG | 7, "\\Device\\Harddisk6\\Partition7"},
 366   {"/dev/sdg8", FH_SDG | 8, "\\Device\\Harddisk6\\Partition8"},
 367   {"/dev/sdg9", FH_SDG | 9, "\\Device\\Harddisk6\\Partition9"},
 368   {"/dev/sdg10", FH_SDG | 10, "\\Device\\Harddisk6\\Partition10"},
 369   {"/dev/sdg11", FH_SDG | 11, "\\Device\\Harddisk6\\Partition11"},
 370   {"/dev/sdg12", FH_SDG | 12, "\\Device\\Harddisk6\\Partition12"},
 371   {"/dev/sdg13", FH_SDG | 13, "\\Device\\Harddisk6\\Partition13"},
 372   {"/dev/sdg14", FH_SDG | 14, "\\Device\\Harddisk6\\Partition14"},
 373   {"/dev/sdg15", FH_SDG | 15, "\\Device\\Harddisk6\\Partition15"},
 374   {"/dev/sdh1", FH_SDH | 1, "\\Device\\Harddisk7\\Partition1"},
 375   {"/dev/sdh2", FH_SDH | 2, "\\Device\\Harddisk7\\Partition2"},
 376   {"/dev/sdh3", FH_SDH | 3, "\\Device\\Harddisk7\\Partition3"},
 377   {"/dev/sdh4", FH_SDH | 4, "\\Device\\Harddisk7\\Partition4"},
 378   {"/dev/sdh5", FH_SDH | 5, "\\Device\\Harddisk7\\Partition5"},
 379   {"/dev/sdh6", FH_SDH | 6, "\\Device\\Harddisk7\\Partition6"},
 380   {"/dev/sdh7", FH_SDH | 7, "\\Device\\Harddisk7\\Partition7"},
 381   {"/dev/sdh8", FH_SDH | 8, "\\Device\\Harddisk7\\Partition8"},
 382   {"/dev/sdh9", FH_SDH | 9, "\\Device\\Harddisk7\\Partition9"},
 383   {"/dev/sdh10", FH_SDH | 10, "\\Device\\Harddisk7\\Partition10"},
 384   {"/dev/sdh11", FH_SDH | 11, "\\Device\\Harddisk7\\Partition11"},
 385   {"/dev/sdh12", FH_SDH | 12, "\\Device\\Harddisk7\\Partition12"},
 386   {"/dev/sdh13", FH_SDH | 13, "\\Device\\Harddisk7\\Partition13"},
 387   {"/dev/sdh14", FH_SDH | 14, "\\Device\\Harddisk7\\Partition14"},
 388   {"/dev/sdh15", FH_SDH | 15, "\\Device\\Harddisk7\\Partition15"},
 389   {"/dev/sdi1", FH_SDI | 1, "\\Device\\Harddisk8\\Partition1"},
 390   {"/dev/sdi2", FH_SDI | 2, "\\Device\\Harddisk8\\Partition2"},
 391   {"/dev/sdi3", FH_SDI | 3, "\\Device\\Harddisk8\\Partition3"},
 392   {"/dev/sdi4", FH_SDI | 4, "\\Device\\Harddisk8\\Partition4"},
 393   {"/dev/sdi5", FH_SDI | 5, "\\Device\\Harddisk8\\Partition5"},
 394   {"/dev/sdi6", FH_SDI | 6, "\\Device\\Harddisk8\\Partition6"},
 395   {"/dev/sdi7", FH_SDI | 7, "\\Device\\Harddisk8\\Partition7"},
 396   {"/dev/sdi8", FH_SDI | 8, "\\Device\\Harddisk8\\Partition8"},
 397   {"/dev/sdi9", FH_SDI | 9, "\\Device\\Harddisk8\\Partition9"},
 398   {"/dev/sdi10", FH_SDI | 10, "\\Device\\Harddisk8\\Partition10"},
 399   {"/dev/sdi11", FH_SDI | 11, "\\Device\\Harddisk8\\Partition11"},
 400   {"/dev/sdi12", FH_SDI | 12, "\\Device\\Harddisk8\\Partition12"},
 401   {"/dev/sdi13", FH_SDI | 13, "\\Device\\Harddisk8\\Partition13"},
 402   {"/dev/sdi14", FH_SDI | 14, "\\Device\\Harddisk8\\Partition14"},
 403   {"/dev/sdi15", FH_SDI | 15, "\\Device\\Harddisk8\\Partition15"},
 404   {"/dev/sdj1", FH_SDJ | 1, "\\Device\\Harddisk9\\Partition1"},
 405   {"/dev/sdj2", FH_SDJ | 2, "\\Device\\Harddisk9\\Partition2"},
 406   {"/dev/sdj3", FH_SDJ | 3, "\\Device\\Harddisk9\\Partition3"},
 407   {"/dev/sdj4", FH_SDJ | 4, "\\Device\\Harddisk9\\Partition4"},
 408   {"/dev/sdj5", FH_SDJ | 5, "\\Device\\Harddisk9\\Partition5"},
 409   {"/dev/sdj6", FH_SDJ | 6, "\\Device\\Harddisk9\\Partition6"},
 410   {"/dev/sdj7", FH_SDJ | 7, "\\Device\\Harddisk9\\Partition7"},
 411   {"/dev/sdj8", FH_SDJ | 8, "\\Device\\Harddisk9\\Partition8"},
 412   {"/dev/sdj9", FH_SDJ | 9, "\\Device\\Harddisk9\\Partition9"},
 413   {"/dev/sdj10", FH_SDJ | 10, "\\Device\\Harddisk9\\Partition10"},
 414   {"/dev/sdj11", FH_SDJ | 11, "\\Device\\Harddisk9\\Partition11"},
 415   {"/dev/sdj12", FH_SDJ | 12, "\\Device\\Harddisk9\\Partition12"},
 416   {"/dev/sdj13", FH_SDJ | 13, "\\Device\\Harddisk9\\Partition13"},
 417   {"/dev/sdj14", FH_SDJ | 14, "\\Device\\Harddisk9\\Partition14"},
 418   {"/dev/sdj15", FH_SDJ | 15, "\\Device\\Harddisk9\\Partition15"},
 419   {"/dev/sdk1", FH_SDK | 1, "\\Device\\Harddisk10\\Partition1"},
 420   {"/dev/sdk2", FH_SDK | 2, "\\Device\\Harddisk10\\Partition2"},
 421   {"/dev/sdk3", FH_SDK | 3, "\\Device\\Harddisk10\\Partition3"},
 422   {"/dev/sdk4", FH_SDK | 4, "\\Device\\Harddisk10\\Partition4"},
 423   {"/dev/sdk5", FH_SDK | 5, "\\Device\\Harddisk10\\Partition5"},
 424   {"/dev/sdk6", FH_SDK | 6, "\\Device\\Harddisk10\\Partition6"},
 425   {"/dev/sdk7", FH_SDK | 7, "\\Device\\Harddisk10\\Partition7"},
 426   {"/dev/sdk8", FH_SDK | 8, "\\Device\\Harddisk10\\Partition8"},
 427   {"/dev/sdk9", FH_SDK | 9, "\\Device\\Harddisk10\\Partition9"},
 428   {"/dev/sdk10", FH_SDK | 10, "\\Device\\Harddisk10\\Partition10"},
 429   {"/dev/sdk11", FH_SDK | 11, "\\Device\\Harddisk10\\Partition11"},
 430   {"/dev/sdk12", FH_SDK | 12, "\\Device\\Harddisk10\\Partition12"},
 431   {"/dev/sdk13", FH_SDK | 13, "\\Device\\Harddisk10\\Partition13"},
 432   {"/dev/sdk14", FH_SDK | 14, "\\Device\\Harddisk10\\Partition14"},
 433   {"/dev/sdk15", FH_SDK | 15, "\\Device\\Harddisk10\\Partition15"},
 434   {"/dev/sdl1", FH_SDL | 1, "\\Device\\Harddisk11\\Partition1"},
 435   {"/dev/sdl2", FH_SDL | 2, "\\Device\\Harddisk11\\Partition2"},
 436   {"/dev/sdl3", FH_SDL | 3, "\\Device\\Harddisk11\\Partition3"},
 437   {"/dev/sdl4", FH_SDL | 4, "\\Device\\Harddisk11\\Partition4"},
 438   {"/dev/sdl5", FH_SDL | 5, "\\Device\\Harddisk11\\Partition5"},
 439   {"/dev/sdl6", FH_SDL | 6, "\\Device\\Harddisk11\\Partition6"},
 440   {"/dev/sdl7", FH_SDL | 7, "\\Device\\Harddisk11\\Partition7"},
 441   {"/dev/sdl8", FH_SDL | 8, "\\Device\\Harddisk11\\Partition8"},
 442   {"/dev/sdl9", FH_SDL | 9, "\\Device\\Harddisk11\\Partition9"},
 443   {"/dev/sdl10", FH_SDL | 10, "\\Device\\Harddisk11\\Partition10"},
 444   {"/dev/sdl11", FH_SDL | 11, "\\Device\\Harddisk11\\Partition11"},
 445   {"/dev/sdl12", FH_SDL | 12, "\\Device\\Harddisk11\\Partition12"},
 446   {"/dev/sdl13", FH_SDL | 13, "\\Device\\Harddisk11\\Partition13"},
 447   {"/dev/sdl14", FH_SDL | 14, "\\Device\\Harddisk11\\Partition14"},
 448   {"/dev/sdl15", FH_SDL | 15, "\\Device\\Harddisk11\\Partition15"},
 449   {"/dev/sdm1", FH_SDM | 1, "\\Device\\Harddisk12\\Partition1"},
 450   {"/dev/sdm2", FH_SDM | 2, "\\Device\\Harddisk12\\Partition2"},
 451   {"/dev/sdm3", FH_SDM | 3, "\\Device\\Harddisk12\\Partition3"},
 452   {"/dev/sdm4", FH_SDM | 4, "\\Device\\Harddisk12\\Partition4"},
 453   {"/dev/sdm5", FH_SDM | 5, "\\Device\\Harddisk12\\Partition5"},
 454   {"/dev/sdm6", FH_SDM | 6, "\\Device\\Harddisk12\\Partition6"},
 455   {"/dev/sdm7", FH_SDM | 7, "\\Device\\Harddisk12\\Partition7"},
 456   {"/dev/sdm8", FH_SDM | 8, "\\Device\\Harddisk12\\Partition8"},
 457   {"/dev/sdm9", FH_SDM | 9, "\\Device\\Harddisk12\\Partition9"},
 458   {"/dev/sdm10", FH_SDM | 10, "\\Device\\Harddisk12\\Partition10"},
 459   {"/dev/sdm11", FH_SDM | 11, "\\Device\\Harddisk12\\Partition11"},
 460   {"/dev/sdm12", FH_SDM | 12, "\\Device\\Harddisk12\\Partition12"},
 461   {"/dev/sdm13", FH_SDM | 13, "\\Device\\Harddisk12\\Partition13"},
 462   {"/dev/sdm14", FH_SDM | 14, "\\Device\\Harddisk12\\Partition14"},
 463   {"/dev/sdm15", FH_SDM | 15, "\\Device\\Harddisk12\\Partition15"},
 464   {"/dev/sdn1", FH_SDN | 1, "\\Device\\Harddisk13\\Partition1"},
 465   {"/dev/sdn2", FH_SDN | 2, "\\Device\\Harddisk13\\Partition2"},
 466   {"/dev/sdn3", FH_SDN | 3, "\\Device\\Harddisk13\\Partition3"},
 467   {"/dev/sdn4", FH_SDN | 4, "\\Device\\Harddisk13\\Partition4"},
 468   {"/dev/sdn5", FH_SDN | 5, "\\Device\\Harddisk13\\Partition5"},
 469   {"/dev/sdn6", FH_SDN | 6, "\\Device\\Harddisk13\\Partition6"},
 470   {"/dev/sdn7", FH_SDN | 7, "\\Device\\Harddisk13\\Partition7"},
 471   {"/dev/sdn8", FH_SDN | 8, "\\Device\\Harddisk13\\Partition8"},
 472   {"/dev/sdn9", FH_SDN | 9, "\\Device\\Harddisk13\\Partition9"},
 473   {"/dev/sdn10", FH_SDN | 10, "\\Device\\Harddisk13\\Partition10"},
 474   {"/dev/sdn11", FH_SDN | 11, "\\Device\\Harddisk13\\Partition11"},
 475   {"/dev/sdn12", FH_SDN | 12, "\\Device\\Harddisk13\\Partition12"},
 476   {"/dev/sdn13", FH_SDN | 13, "\\Device\\Harddisk13\\Partition13"},
 477   {"/dev/sdn14", FH_SDN | 14, "\\Device\\Harddisk13\\Partition14"},
 478   {"/dev/sdn15", FH_SDN | 15, "\\Device\\Harddisk13\\Partition15"},
 479   {"/dev/sdo1", FH_SDO | 1, "\\Device\\Harddisk14\\Partition1"},
 480   {"/dev/sdo2", FH_SDO | 2, "\\Device\\Harddisk14\\Partition2"},
 481   {"/dev/sdo3", FH_SDO | 3, "\\Device\\Harddisk14\\Partition3"},
 482   {"/dev/sdo4", FH_SDO | 4, "\\Device\\Harddisk14\\Partition4"},
 483   {"/dev/sdo5", FH_SDO | 5, "\\Device\\Harddisk14\\Partition5"},
 484   {"/dev/sdo6", FH_SDO | 6, "\\Device\\Harddisk14\\Partition6"},
 485   {"/dev/sdo7", FH_SDO | 7, "\\Device\\Harddisk14\\Partition7"},
 486   {"/dev/sdo8", FH_SDO | 8, "\\Device\\Harddisk14\\Partition8"},
 487   {"/dev/sdo9", FH_SDO | 9, "\\Device\\Harddisk14\\Partition9"},
 488   {"/dev/sdo10", FH_SDO | 10, "\\Device\\Harddisk14\\Partition10"},
 489   {"/dev/sdo11", FH_SDO | 11, "\\Device\\Harddisk14\\Partition11"},
 490   {"/dev/sdo12", FH_SDO | 12, "\\Device\\Harddisk14\\Partition12"},
 491   {"/dev/sdo13", FH_SDO | 13, "\\Device\\Harddisk14\\Partition13"},
 492   {"/dev/sdo14", FH_SDO | 14, "\\Device\\Harddisk14\\Partition14"},
 493   {"/dev/sdo15", FH_SDO | 15, "\\Device\\Harddisk14\\Partition15"},
 494   {"/dev/sdp1", FH_SDP | 1, "\\Device\\Harddisk15\\Partition1"},
 495   {"/dev/sdp2", FH_SDP | 2, "\\Device\\Harddisk15\\Partition2"},
 496   {"/dev/sdp3", FH_SDP | 3, "\\Device\\Harddisk15\\Partition3"},
 497   {"/dev/sdp4", FH_SDP | 4, "\\Device\\Harddisk15\\Partition4"},
 498   {"/dev/sdp5", FH_SDP | 5, "\\Device\\Harddisk15\\Partition5"},
 499   {"/dev/sdp6", FH_SDP | 6, "\\Device\\Harddisk15\\Partition6"},
 500   {"/dev/sdp7", FH_SDP | 7, "\\Device\\Harddisk15\\Partition7"},
 501   {"/dev/sdp8", FH_SDP | 8, "\\Device\\Harddisk15\\Partition8"},
 502   {"/dev/sdp9", FH_SDP | 9, "\\Device\\Harddisk15\\Partition9"},
 503   {"/dev/sdp10", FH_SDP | 10, "\\Device\\Harddisk15\\Partition10"},
 504   {"/dev/sdp11", FH_SDP | 11, "\\Device\\Harddisk15\\Partition11"},
 505   {"/dev/sdp12", FH_SDP | 12, "\\Device\\Harddisk15\\Partition12"},
 506   {"/dev/sdp13", FH_SDP | 13, "\\Device\\Harddisk15\\Partition13"},
 507   {"/dev/sdp14", FH_SDP | 14, "\\Device\\Harddisk15\\Partition14"},
 508   {"/dev/sdp15", FH_SDP | 15, "\\Device\\Harddisk15\\Partition15"},
 509   {"/dev/sdq1", FH_SDQ | 1, "\\Device\\Harddisk16\\Partition1"},
 510   {"/dev/sdq2", FH_SDQ | 2, "\\Device\\Harddisk16\\Partition2"},
 511   {"/dev/sdq3", FH_SDQ | 3, "\\Device\\Harddisk16\\Partition3"},
 512   {"/dev/sdq4", FH_SDQ | 4, "\\Device\\Harddisk16\\Partition4"},
 513   {"/dev/sdq5", FH_SDQ | 5, "\\Device\\Harddisk16\\Partition5"},
 514   {"/dev/sdq6", FH_SDQ | 6, "\\Device\\Harddisk16\\Partition6"},
 515   {"/dev/sdq7", FH_SDQ | 7, "\\Device\\Harddisk16\\Partition7"},
 516   {"/dev/sdq8", FH_SDQ | 8, "\\Device\\Harddisk16\\Partition8"},
 517   {"/dev/sdq9", FH_SDQ | 9, "\\Device\\Harddisk16\\Partition9"},
 518   {"/dev/sdq10", FH_SDQ | 10, "\\Device\\Harddisk16\\Partition10"},
 519   {"/dev/sdq11", FH_SDQ | 11, "\\Device\\Harddisk16\\Partition11"},
 520   {"/dev/sdq12", FH_SDQ | 12, "\\Device\\Harddisk16\\Partition12"},
 521   {"/dev/sdq13", FH_SDQ | 13, "\\Device\\Harddisk16\\Partition13"},
 522   {"/dev/sdq14", FH_SDQ | 14, "\\Device\\Harddisk16\\Partition14"},
 523   {"/dev/sdq15", FH_SDQ | 15, "\\Device\\Harddisk16\\Partition15"},
 524   {"/dev/sdr1", FH_SDR | 1, "\\Device\\Harddisk17\\Partition1"},
 525   {"/dev/sdr2", FH_SDR | 2, "\\Device\\Harddisk17\\Partition2"},
 526   {"/dev/sdr3", FH_SDR | 3, "\\Device\\Harddisk17\\Partition3"},
 527   {"/dev/sdr4", FH_SDR | 4, "\\Device\\Harddisk17\\Partition4"},
 528   {"/dev/sdr5", FH_SDR | 5, "\\Device\\Harddisk17\\Partition5"},
 529   {"/dev/sdr6", FH_SDR | 6, "\\Device\\Harddisk17\\Partition6"},
 530   {"/dev/sdr7", FH_SDR | 7, "\\Device\\Harddisk17\\Partition7"},
 531   {"/dev/sdr8", FH_SDR | 8, "\\Device\\Harddisk17\\Partition8"},
 532   {"/dev/sdr9", FH_SDR | 9, "\\Device\\Harddisk17\\Partition9"},
 533   {"/dev/sdr10", FH_SDR | 10, "\\Device\\Harddisk17\\Partition10"},
 534   {"/dev/sdr11", FH_SDR | 11, "\\Device\\Harddisk17\\Partition11"},
 535   {"/dev/sdr12", FH_SDR | 12, "\\Device\\Harddisk17\\Partition12"},
 536   {"/dev/sdr13", FH_SDR | 13, "\\Device\\Harddisk17\\Partition13"},
 537   {"/dev/sdr14", FH_SDR | 14, "\\Device\\Harddisk17\\Partition14"},
 538   {"/dev/sdr15", FH_SDR | 15, "\\Device\\Harddisk17\\Partition15"},
 539   {"/dev/sds1", FH_SDS | 1, "\\Device\\Harddisk18\\Partition1"},
 540   {"/dev/sds2", FH_SDS | 2, "\\Device\\Harddisk18\\Partition2"},
 541   {"/dev/sds3", FH_SDS | 3, "\\Device\\Harddisk18\\Partition3"},
 542   {"/dev/sds4", FH_SDS | 4, "\\Device\\Harddisk18\\Partition4"},
 543   {"/dev/sds5", FH_SDS | 5, "\\Device\\Harddisk18\\Partition5"},
 544   {"/dev/sds6", FH_SDS | 6, "\\Device\\Harddisk18\\Partition6"},
 545   {"/dev/sds7", FH_SDS | 7, "\\Device\\Harddisk18\\Partition7"},
 546   {"/dev/sds8", FH_SDS | 8, "\\Device\\Harddisk18\\Partition8"},
 547   {"/dev/sds9", FH_SDS | 9, "\\Device\\Harddisk18\\Partition9"},
 548   {"/dev/sds10", FH_SDS | 10, "\\Device\\Harddisk18\\Partition10"},
 549   {"/dev/sds11", FH_SDS | 11, "\\Device\\Harddisk18\\Partition11"},
 550   {"/dev/sds12", FH_SDS | 12, "\\Device\\Harddisk18\\Partition12"},
 551   {"/dev/sds13", FH_SDS | 13, "\\Device\\Harddisk18\\Partition13"},
 552   {"/dev/sds14", FH_SDS | 14, "\\Device\\Harddisk18\\Partition14"},
 553   {"/dev/sds15", FH_SDS | 15, "\\Device\\Harddisk18\\Partition15"},
 554   {"/dev/sdt1", FH_SDT | 1, "\\Device\\Harddisk19\\Partition1"},
 555   {"/dev/sdt2", FH_SDT | 2, "\\Device\\Harddisk19\\Partition2"},
 556   {"/dev/sdt3", FH_SDT | 3, "\\Device\\Harddisk19\\Partition3"},
 557   {"/dev/sdt4", FH_SDT | 4, "\\Device\\Harddisk19\\Partition4"},
 558   {"/dev/sdt5", FH_SDT | 5, "\\Device\\Harddisk19\\Partition5"},
 559   {"/dev/sdt6", FH_SDT | 6, "\\Device\\Harddisk19\\Partition6"},
 560   {"/dev/sdt7", FH_SDT | 7, "\\Device\\Harddisk19\\Partition7"},
 561   {"/dev/sdt8", FH_SDT | 8, "\\Device\\Harddisk19\\Partition8"},
 562   {"/dev/sdt9", FH_SDT | 9, "\\Device\\Harddisk19\\Partition9"},
 563   {"/dev/sdt10", FH_SDT | 10, "\\Device\\Harddisk19\\Partition10"},
 564   {"/dev/sdt11", FH_SDT | 11, "\\Device\\Harddisk19\\Partition11"},
 565   {"/dev/sdt12", FH_SDT | 12, "\\Device\\Harddisk19\\Partition12"},
 566   {"/dev/sdt13", FH_SDT | 13, "\\Device\\Harddisk19\\Partition13"},
 567   {"/dev/sdt14", FH_SDT | 14, "\\Device\\Harddisk19\\Partition14"},
 568   {"/dev/sdt15", FH_SDT | 15, "\\Device\\Harddisk19\\Partition15"},
 569   {"/dev/sdu1", FH_SDU | 1, "\\Device\\Harddisk20\\Partition1"},
 570   {"/dev/sdu2", FH_SDU | 2, "\\Device\\Harddisk20\\Partition2"},
 571   {"/dev/sdu3", FH_SDU | 3, "\\Device\\Harddisk20\\Partition3"},
 572   {"/dev/sdu4", FH_SDU | 4, "\\Device\\Harddisk20\\Partition4"},
 573   {"/dev/sdu5", FH_SDU | 5, "\\Device\\Harddisk20\\Partition5"},
 574   {"/dev/sdu6", FH_SDU | 6, "\\Device\\Harddisk20\\Partition6"},
 575   {"/dev/sdu7", FH_SDU | 7, "\\Device\\Harddisk20\\Partition7"},
 576   {"/dev/sdu8", FH_SDU | 8, "\\Device\\Harddisk20\\Partition8"},
 577   {"/dev/sdu9", FH_SDU | 9, "\\Device\\Harddisk20\\Partition9"},
 578   {"/dev/sdu10", FH_SDU | 10, "\\Device\\Harddisk20\\Partition10"},
 579   {"/dev/sdu11", FH_SDU | 11, "\\Device\\Harddisk20\\Partition11"},
 580   {"/dev/sdu12", FH_SDU | 12, "\\Device\\Harddisk20\\Partition12"},
 581   {"/dev/sdu13", FH_SDU | 13, "\\Device\\Harddisk20\\Partition13"},
 582   {"/dev/sdu14", FH_SDU | 14, "\\Device\\Harddisk20\\Partition14"},
 583   {"/dev/sdu15", FH_SDU | 15, "\\Device\\Harddisk20\\Partition15"},
 584   {"/dev/sdv1", FH_SDV | 1, "\\Device\\Harddisk21\\Partition1"},
 585   {"/dev/sdv2", FH_SDV | 2, "\\Device\\Harddisk21\\Partition2"},
 586   {"/dev/sdv3", FH_SDV | 3, "\\Device\\Harddisk21\\Partition3"},
 587   {"/dev/sdv4", FH_SDV | 4, "\\Device\\Harddisk21\\Partition4"},
 588   {"/dev/sdv5", FH_SDV | 5, "\\Device\\Harddisk21\\Partition5"},
 589   {"/dev/sdv6", FH_SDV | 6, "\\Device\\Harddisk21\\Partition6"},
 590   {"/dev/sdv7", FH_SDV | 7, "\\Device\\Harddisk21\\Partition7"},
 591   {"/dev/sdv8", FH_SDV | 8, "\\Device\\Harddisk21\\Partition8"},
 592   {"/dev/sdv9", FH_SDV | 9, "\\Device\\Harddisk21\\Partition9"},
 593   {"/dev/sdv10", FH_SDV | 10, "\\Device\\Harddisk21\\Partition10"},
 594   {"/dev/sdv11", FH_SDV | 11, "\\Device\\Harddisk21\\Partition11"},
 595   {"/dev/sdv12", FH_SDV | 12, "\\Device\\Harddisk21\\Partition12"},
 596   {"/dev/sdv13", FH_SDV | 13, "\\Device\\Harddisk21\\Partition13"},
 597   {"/dev/sdv14", FH_SDV | 14, "\\Device\\Harddisk21\\Partition14"},
 598   {"/dev/sdv15", FH_SDV | 15, "\\Device\\Harddisk21\\Partition15"},
 599   {"/dev/sdw1", FH_SDW | 1, "\\Device\\Harddisk22\\Partition1"},
 600   {"/dev/sdw2", FH_SDW | 2, "\\Device\\Harddisk22\\Partition2"},
 601   {"/dev/sdw3", FH_SDW | 3, "\\Device\\Harddisk22\\Partition3"},
 602   {"/dev/sdw4", FH_SDW | 4, "\\Device\\Harddisk22\\Partition4"},
 603   {"/dev/sdw5", FH_SDW | 5, "\\Device\\Harddisk22\\Partition5"},
 604   {"/dev/sdw6", FH_SDW | 6, "\\Device\\Harddisk22\\Partition6"},
 605   {"/dev/sdw7", FH_SDW | 7, "\\Device\\Harddisk22\\Partition7"},
 606   {"/dev/sdw8", FH_SDW | 8, "\\Device\\Harddisk22\\Partition8"},
 607   {"/dev/sdw9", FH_SDW | 9, "\\Device\\Harddisk22\\Partition9"},
 608   {"/dev/sdw10", FH_SDW | 10, "\\Device\\Harddisk22\\Partition10"},
 609   {"/dev/sdw11", FH_SDW | 11, "\\Device\\Harddisk22\\Partition11"},
 610   {"/dev/sdw12", FH_SDW | 12, "\\Device\\Harddisk22\\Partition12"},
 611   {"/dev/sdw13", FH_SDW | 13, "\\Device\\Harddisk22\\Partition13"},
 612   {"/dev/sdw14", FH_SDW | 14, "\\Device\\Harddisk22\\Partition14"},
 613   {"/dev/sdw15", FH_SDW | 15, "\\Device\\Harddisk22\\Partition15"},
 614   {"/dev/sdx1", FH_SDX | 1, "\\Device\\Harddisk23\\Partition1"},
 615   {"/dev/sdx2", FH_SDX | 2, "\\Device\\Harddisk23\\Partition2"},
 616   {"/dev/sdx3", FH_SDX | 3, "\\Device\\Harddisk23\\Partition3"},
 617   {"/dev/sdx4", FH_SDX | 4, "\\Device\\Harddisk23\\Partition4"},
 618   {"/dev/sdx5", FH_SDX | 5, "\\Device\\Harddisk23\\Partition5"},
 619   {"/dev/sdx6", FH_SDX | 6, "\\Device\\Harddisk23\\Partition6"},
 620   {"/dev/sdx7", FH_SDX | 7, "\\Device\\Harddisk23\\Partition7"},
 621   {"/dev/sdx8", FH_SDX | 8, "\\Device\\Harddisk23\\Partition8"},
 622   {"/dev/sdx9", FH_SDX | 9, "\\Device\\Harddisk23\\Partition9"},
 623   {"/dev/sdx10", FH_SDX | 10, "\\Device\\Harddisk23\\Partition10"},
 624   {"/dev/sdx11", FH_SDX | 11, "\\Device\\Harddisk23\\Partition11"},
 625   {"/dev/sdx12", FH_SDX | 12, "\\Device\\Harddisk23\\Partition12"},
 626   {"/dev/sdx13", FH_SDX | 13, "\\Device\\Harddisk23\\Partition13"},
 627   {"/dev/sdx14", FH_SDX | 14, "\\Device\\Harddisk23\\Partition14"},
 628   {"/dev/sdx15", FH_SDX | 15, "\\Device\\Harddisk23\\Partition15"},
 629   {"/dev/sdy1", FH_SDY | 1, "\\Device\\Harddisk24\\Partition1"},
 630   {"/dev/sdy2", FH_SDY | 2, "\\Device\\Harddisk24\\Partition2"},
 631   {"/dev/sdy3", FH_SDY | 3, "\\Device\\Harddisk24\\Partition3"},
 632   {"/dev/sdy4", FH_SDY | 4, "\\Device\\Harddisk24\\Partition4"},
 633   {"/dev/sdy5", FH_SDY | 5, "\\Device\\Harddisk24\\Partition5"},
 634   {"/dev/sdy6", FH_SDY | 6, "\\Device\\Harddisk24\\Partition6"},
 635   {"/dev/sdy7", FH_SDY | 7, "\\Device\\Harddisk24\\Partition7"},
 636   {"/dev/sdy8", FH_SDY | 8, "\\Device\\Harddisk24\\Partition8"},
 637   {"/dev/sdy9", FH_SDY | 9, "\\Device\\Harddisk24\\Partition9"},
 638   {"/dev/sdy10", FH_SDY | 10, "\\Device\\Harddisk24\\Partition10"},
 639   {"/dev/sdy11", FH_SDY | 11, "\\Device\\Harddisk24\\Partition11"},
 640   {"/dev/sdy12", FH_SDY | 12, "\\Device\\Harddisk24\\Partition12"},
 641   {"/dev/sdy13", FH_SDY | 13, "\\Device\\Harddisk24\\Partition13"},
 642   {"/dev/sdy14", FH_SDY | 14, "\\Device\\Harddisk24\\Partition14"},
 643   {"/dev/sdy15", FH_SDY | 15, "\\Device\\Harddisk24\\Partition15"},
 644   {"/dev/sdz1", FH_SDZ | 1, "\\Device\\Harddisk25\\Partition1"},
 645   {"/dev/sdz2", FH_SDZ | 2, "\\Device\\Harddisk25\\Partition2"},
 646   {"/dev/sdz3", FH_SDZ | 3, "\\Device\\Harddisk25\\Partition3"},
 647   {"/dev/sdz4", FH_SDZ | 4, "\\Device\\Harddisk25\\Partition4"},
 648   {"/dev/sdz5", FH_SDZ | 5, "\\Device\\Harddisk25\\Partition5"},
 649   {"/dev/sdz6", FH_SDZ | 6, "\\Device\\Harddisk25\\Partition6"},
 650   {"/dev/sdz7", FH_SDZ | 7, "\\Device\\Harddisk25\\Partition7"},
 651   {"/dev/sdz8", FH_SDZ | 8, "\\Device\\Harddisk25\\Partition8"},
 652   {"/dev/sdz9", FH_SDZ | 9, "\\Device\\Harddisk25\\Partition9"},
 653   {"/dev/sdz10", FH_SDZ | 10, "\\Device\\Harddisk25\\Partition10"},
 654   {"/dev/sdz11", FH_SDZ | 11, "\\Device\\Harddisk25\\Partition11"},
 655   {"/dev/sdz12", FH_SDZ | 12, "\\Device\\Harddisk25\\Partition12"},
 656   {"/dev/sdz13", FH_SDZ | 13, "\\Device\\Harddisk25\\Partition13"},
 657   {"/dev/sdz14", FH_SDZ | 14, "\\Device\\Harddisk25\\Partition14"},
 658   {"/dev/sdz15", FH_SDZ | 15, "\\Device\\Harddisk25\\Partition15"},
 659   {"/dev/sr0", FHDEV(DEV_CDROM_MAJOR, 0), "\\Device\\CdRom0"},
 660   {"/dev/sr1", FHDEV(DEV_CDROM_MAJOR, 1), "\\Device\\CdRom1"},
 661   {"/dev/sr2", FHDEV(DEV_CDROM_MAJOR, 2), "\\Device\\CdRom2"},
 662   {"/dev/sr3", FHDEV(DEV_CDROM_MAJOR, 3), "\\Device\\CdRom3"},
 663   {"/dev/sr4", FHDEV(DEV_CDROM_MAJOR, 4), "\\Device\\CdRom4"},
 664   {"/dev/sr5", FHDEV(DEV_CDROM_MAJOR, 5), "\\Device\\CdRom5"},
 665   {"/dev/sr6", FHDEV(DEV_CDROM_MAJOR, 6), "\\Device\\CdRom6"},
 666   {"/dev/sr7", FHDEV(DEV_CDROM_MAJOR, 7), "\\Device\\CdRom7"},
 667   {"/dev/sr8", FHDEV(DEV_CDROM_MAJOR, 8), "\\Device\\CdRom8"},
 668   {"/dev/sr9", FHDEV(DEV_CDROM_MAJOR, 9), "\\Device\\CdRom9"},
 669   {"/dev/sr10", FHDEV(DEV_CDROM_MAJOR, 10), "\\Device\\CdRom10"},
 670   {"/dev/sr11", FHDEV(DEV_CDROM_MAJOR, 11), "\\Device\\CdRom11"},
 671   {"/dev/sr12", FHDEV(DEV_CDROM_MAJOR, 12), "\\Device\\CdRom12"},
 672   {"/dev/sr13", FHDEV(DEV_CDROM_MAJOR, 13), "\\Device\\CdRom13"},
 673   {"/dev/sr14", FHDEV(DEV_CDROM_MAJOR, 14), "\\Device\\CdRom14"},
 674   {"/dev/sr15", FHDEV(DEV_CDROM_MAJOR, 15), "\\Device\\CdRom15"},
 675   {"/dev/st0", FHDEV(DEV_TAPE_MAJOR, 0), "\\Device\\Tape0"},
 676   {"/dev/st1", FHDEV(DEV_TAPE_MAJOR, 1), "\\Device\\Tape1"},
 677   {"/dev/st2", FHDEV(DEV_TAPE_MAJOR, 2), "\\Device\\Tape2"},
 678   {"/dev/st3", FHDEV(DEV_TAPE_MAJOR, 3), "\\Device\\Tape3"},
 679   {"/dev/st4", FHDEV(DEV_TAPE_MAJOR, 4), "\\Device\\Tape4"},
 680   {"/dev/st5", FHDEV(DEV_TAPE_MAJOR, 5), "\\Device\\Tape5"},
 681   {"/dev/st6", FHDEV(DEV_TAPE_MAJOR, 6), "\\Device\\Tape6"},
 682   {"/dev/st7", FHDEV(DEV_TAPE_MAJOR, 7), "\\Device\\Tape7"},
 683   {"/dev/st8", FHDEV(DEV_TAPE_MAJOR, 8), "\\Device\\Tape8"},
 684   {"/dev/st9", FHDEV(DEV_TAPE_MAJOR, 9), "\\Device\\Tape9"},
 685   {"/dev/st10", FHDEV(DEV_TAPE_MAJOR, 10), "\\Device\\Tape10"},
 686   {"/dev/st11", FHDEV(DEV_TAPE_MAJOR, 11), "\\Device\\Tape11"},
 687   {"/dev/st12", FHDEV(DEV_TAPE_MAJOR, 12), "\\Device\\Tape12"},
 688   {"/dev/st13", FHDEV(DEV_TAPE_MAJOR, 13), "\\Device\\Tape13"},
 689   {"/dev/st14", FHDEV(DEV_TAPE_MAJOR, 14), "\\Device\\Tape14"},
 690   {"/dev/st15", FHDEV(DEV_TAPE_MAJOR, 15), "\\Device\\Tape15"},
 691   {"/dev/st16", FHDEV(DEV_TAPE_MAJOR, 16), "\\Device\\Tape16"},
 692   {"/dev/st17", FHDEV(DEV_TAPE_MAJOR, 17), "\\Device\\Tape17"},
 693   {"/dev/st18", FHDEV(DEV_TAPE_MAJOR, 18), "\\Device\\Tape18"},
 694   {"/dev/st19", FHDEV(DEV_TAPE_MAJOR, 19), "\\Device\\Tape19"},
 695   {"/dev/st20", FHDEV(DEV_TAPE_MAJOR, 20), "\\Device\\Tape20"},
 696   {"/dev/st21", FHDEV(DEV_TAPE_MAJOR, 21), "\\Device\\Tape21"},
 697   {"/dev/st22", FHDEV(DEV_TAPE_MAJOR, 22), "\\Device\\Tape22"},
 698   {"/dev/st23", FHDEV(DEV_TAPE_MAJOR, 23), "\\Device\\Tape23"},
 699   {"/dev/st24", FHDEV(DEV_TAPE_MAJOR, 24), "\\Device\\Tape24"},
 700   {"/dev/st25", FHDEV(DEV_TAPE_MAJOR, 25), "\\Device\\Tape25"},
 701   {"/dev/st26", FHDEV(DEV_TAPE_MAJOR, 26), "\\Device\\Tape26"},
 702   {"/dev/st27", FHDEV(DEV_TAPE_MAJOR, 27), "\\Device\\Tape27"},
 703   {"/dev/st28", FHDEV(DEV_TAPE_MAJOR, 28), "\\Device\\Tape28"},
 704   {"/dev/st29", FHDEV(DEV_TAPE_MAJOR, 29), "\\Device\\Tape29"},
 705   {"/dev/st30", FHDEV(DEV_TAPE_MAJOR, 30), "\\Device\\Tape30"},
 706   {"/dev/st31", FHDEV(DEV_TAPE_MAJOR, 31), "\\Device\\Tape31"},
 707   {"/dev/st32", FHDEV(DEV_TAPE_MAJOR, 32), "\\Device\\Tape32"},
 708   {"/dev/st33", FHDEV(DEV_TAPE_MAJOR, 33), "\\Device\\Tape33"},
 709   {"/dev/st34", FHDEV(DEV_TAPE_MAJOR, 34), "\\Device\\Tape34"},
 710   {"/dev/st35", FHDEV(DEV_TAPE_MAJOR, 35), "\\Device\\Tape35"},
 711   {"/dev/st36", FHDEV(DEV_TAPE_MAJOR, 36), "\\Device\\Tape36"},
 712   {"/dev/st37", FHDEV(DEV_TAPE_MAJOR, 37), "\\Device\\Tape37"},
 713   {"/dev/st38", FHDEV(DEV_TAPE_MAJOR, 38), "\\Device\\Tape38"},
 714   {"/dev/st39", FHDEV(DEV_TAPE_MAJOR, 39), "\\Device\\Tape39"},
 715   {"/dev/st40", FHDEV(DEV_TAPE_MAJOR, 40), "\\Device\\Tape40"},
 716   {"/dev/st41", FHDEV(DEV_TAPE_MAJOR, 41), "\\Device\\Tape41"},
 717   {"/dev/st42", FHDEV(DEV_TAPE_MAJOR, 42), "\\Device\\Tape42"},
 718   {"/dev/st43", FHDEV(DEV_TAPE_MAJOR, 43), "\\Device\\Tape43"},
 719   {"/dev/st44", FHDEV(DEV_TAPE_MAJOR, 44), "\\Device\\Tape44"},
 720   {"/dev/st45", FHDEV(DEV_TAPE_MAJOR, 45), "\\Device\\Tape45"},
 721   {"/dev/st46", FHDEV(DEV_TAPE_MAJOR, 46), "\\Device\\Tape46"},
 722   {"/dev/st47", FHDEV(DEV_TAPE_MAJOR, 47), "\\Device\\Tape47"},
 723   {"/dev/st48", FHDEV(DEV_TAPE_MAJOR, 48), "\\Device\\Tape48"},
 724   {"/dev/st49", FHDEV(DEV_TAPE_MAJOR, 49), "\\Device\\Tape49"},
 725   {"/dev/st50", FHDEV(DEV_TAPE_MAJOR, 50), "\\Device\\Tape50"},
 726   {"/dev/st51", FHDEV(DEV_TAPE_MAJOR, 51), "\\Device\\Tape51"},
 727   {"/dev/st52", FHDEV(DEV_TAPE_MAJOR, 52), "\\Device\\Tape52"},
 728   {"/dev/st53", FHDEV(DEV_TAPE_MAJOR, 53), "\\Device\\Tape53"},
 729   {"/dev/st54", FHDEV(DEV_TAPE_MAJOR, 54), "\\Device\\Tape54"},
 730   {"/dev/st55", FHDEV(DEV_TAPE_MAJOR, 55), "\\Device\\Tape55"},
 731   {"/dev/st56", FHDEV(DEV_TAPE_MAJOR, 56), "\\Device\\Tape56"},
 732   {"/dev/st57", FHDEV(DEV_TAPE_MAJOR, 57), "\\Device\\Tape57"},
 733   {"/dev/st58", FHDEV(DEV_TAPE_MAJOR, 58), "\\Device\\Tape58"},
 734   {"/dev/st59", FHDEV(DEV_TAPE_MAJOR, 59), "\\Device\\Tape59"},
 735   {"/dev/st60", FHDEV(DEV_TAPE_MAJOR, 60), "\\Device\\Tape60"},
 736   {"/dev/st61", FHDEV(DEV_TAPE_MAJOR, 61), "\\Device\\Tape61"},
 737   {"/dev/st62", FHDEV(DEV_TAPE_MAJOR, 62), "\\Device\\Tape62"},
 738   {"/dev/st63", FHDEV(DEV_TAPE_MAJOR, 63), "\\Device\\Tape63"},
 739   {"/dev/st64", FHDEV(DEV_TAPE_MAJOR, 64), "\\Device\\Tape64"},
 740   {"/dev/st65", FHDEV(DEV_TAPE_MAJOR, 65), "\\Device\\Tape65"},
 741   {"/dev/st66", FHDEV(DEV_TAPE_MAJOR, 66), "\\Device\\Tape66"},
 742   {"/dev/st67", FHDEV(DEV_TAPE_MAJOR, 67), "\\Device\\Tape67"},
 743   {"/dev/st68", FHDEV(DEV_TAPE_MAJOR, 68), "\\Device\\Tape68"},
 744   {"/dev/st69", FHDEV(DEV_TAPE_MAJOR, 69), "\\Device\\Tape69"},
 745   {"/dev/st70", FHDEV(DEV_TAPE_MAJOR, 70), "\\Device\\Tape70"},
 746   {"/dev/st71", FHDEV(DEV_TAPE_MAJOR, 71), "\\Device\\Tape71"},
 747   {"/dev/st72", FHDEV(DEV_TAPE_MAJOR, 72), "\\Device\\Tape72"},
 748   {"/dev/st73", FHDEV(DEV_TAPE_MAJOR, 73), "\\Device\\Tape73"},
 749   {"/dev/st74", FHDEV(DEV_TAPE_MAJOR, 74), "\\Device\\Tape74"},
 750   {"/dev/st75", FHDEV(DEV_TAPE_MAJOR, 75), "\\Device\\Tape75"},
 751   {"/dev/st76", FHDEV(DEV_TAPE_MAJOR, 76), "\\Device\\Tape76"},
 752   {"/dev/st77", FHDEV(DEV_TAPE_MAJOR, 77), "\\Device\\Tape77"},
 753   {"/dev/st78", FHDEV(DEV_TAPE_MAJOR, 78), "\\Device\\Tape78"},
 754   {"/dev/st79", FHDEV(DEV_TAPE_MAJOR, 79), "\\Device\\Tape79"},
 755   {"/dev/st80", FHDEV(DEV_TAPE_MAJOR, 80), "\\Device\\Tape80"},
 756   {"/dev/st81", FHDEV(DEV_TAPE_MAJOR, 81), "\\Device\\Tape81"},
 757   {"/dev/st82", FHDEV(DEV_TAPE_MAJOR, 82), "\\Device\\Tape82"},
 758   {"/dev/st83", FHDEV(DEV_TAPE_MAJOR, 83), "\\Device\\Tape83"},
 759   {"/dev/st84", FHDEV(DEV_TAPE_MAJOR, 84), "\\Device\\Tape84"},
 760   {"/dev/st85", FHDEV(DEV_TAPE_MAJOR, 85), "\\Device\\Tape85"},
 761   {"/dev/st86", FHDEV(DEV_TAPE_MAJOR, 86), "\\Device\\Tape86"},
 762   {"/dev/st87", FHDEV(DEV_TAPE_MAJOR, 87), "\\Device\\Tape87"},
 763   {"/dev/st88", FHDEV(DEV_TAPE_MAJOR, 88), "\\Device\\Tape88"},
 764   {"/dev/st89", FHDEV(DEV_TAPE_MAJOR, 89), "\\Device\\Tape89"},
 765   {"/dev/st90", FHDEV(DEV_TAPE_MAJOR, 90), "\\Device\\Tape90"},
 766   {"/dev/st91", FHDEV(DEV_TAPE_MAJOR, 91), "\\Device\\Tape91"},
 767   {"/dev/st92", FHDEV(DEV_TAPE_MAJOR, 92), "\\Device\\Tape92"},
 768   {"/dev/st93", FHDEV(DEV_TAPE_MAJOR, 93), "\\Device\\Tape93"},
 769   {"/dev/st94", FHDEV(DEV_TAPE_MAJOR, 94), "\\Device\\Tape94"},
 770   {"/dev/st95", FHDEV(DEV_TAPE_MAJOR, 95), "\\Device\\Tape95"},
 771   {"/dev/st96", FHDEV(DEV_TAPE_MAJOR, 96), "\\Device\\Tape96"},
 772   {"/dev/st97", FHDEV(DEV_TAPE_MAJOR, 97), "\\Device\\Tape97"},
 773   {"/dev/st98", FHDEV(DEV_TAPE_MAJOR, 98), "\\Device\\Tape98"},
 774   {"/dev/st99", FHDEV(DEV_TAPE_MAJOR, 99), "\\Device\\Tape99"},
 775   {"/dev/st100", FHDEV(DEV_TAPE_MAJOR, 100), "\\Device\\Tape100"},
 776   {"/dev/st101", FHDEV(DEV_TAPE_MAJOR, 101), "\\Device\\Tape101"},
 777   {"/dev/st102", FHDEV(DEV_TAPE_MAJOR, 102), "\\Device\\Tape102"},
 778   {"/dev/st103", FHDEV(DEV_TAPE_MAJOR, 103), "\\Device\\Tape103"},
 779   {"/dev/st104", FHDEV(DEV_TAPE_MAJOR, 104), "\\Device\\Tape104"},
 780   {"/dev/st105", FHDEV(DEV_TAPE_MAJOR, 105), "\\Device\\Tape105"},
 781   {"/dev/st106", FHDEV(DEV_TAPE_MAJOR, 106), "\\Device\\Tape106"},
 782   {"/dev/st107", FHDEV(DEV_TAPE_MAJOR, 107), "\\Device\\Tape107"},
 783   {"/dev/st108", FHDEV(DEV_TAPE_MAJOR, 108), "\\Device\\Tape108"},
 784   {"/dev/st109", FHDEV(DEV_TAPE_MAJOR, 109), "\\Device\\Tape109"},
 785   {"/dev/st110", FHDEV(DEV_TAPE_MAJOR, 110), "\\Device\\Tape110"},
 786   {"/dev/st111", FHDEV(DEV_TAPE_MAJOR, 111), "\\Device\\Tape111"},
 787   {"/dev/st112", FHDEV(DEV_TAPE_MAJOR, 112), "\\Device\\Tape112"},
 788   {"/dev/st113", FHDEV(DEV_TAPE_MAJOR, 113), "\\Device\\Tape113"},
 789   {"/dev/st114", FHDEV(DEV_TAPE_MAJOR, 114), "\\Device\\Tape114"},
 790   {"/dev/st115", FHDEV(DEV_TAPE_MAJOR, 115), "\\Device\\Tape115"},
 791   {"/dev/st116", FHDEV(DEV_TAPE_MAJOR, 116), "\\Device\\Tape116"},
 792   {"/dev/st117", FHDEV(DEV_TAPE_MAJOR, 117), "\\Device\\Tape117"},
 793   {"/dev/st118", FHDEV(DEV_TAPE_MAJOR, 118), "\\Device\\Tape118"},
 794   {"/dev/st119", FHDEV(DEV_TAPE_MAJOR, 119), "\\Device\\Tape119"},
 795   {"/dev/st120", FHDEV(DEV_TAPE_MAJOR, 120), "\\Device\\Tape120"},
 796   {"/dev/st121", FHDEV(DEV_TAPE_MAJOR, 121), "\\Device\\Tape121"},
 797   {"/dev/st122", FHDEV(DEV_TAPE_MAJOR, 122), "\\Device\\Tape122"},
 798   {"/dev/st123", FHDEV(DEV_TAPE_MAJOR, 123), "\\Device\\Tape123"},
 799   {"/dev/st124", FHDEV(DEV_TAPE_MAJOR, 124), "\\Device\\Tape124"},
 800   {"/dev/st125", FHDEV(DEV_TAPE_MAJOR, 125), "\\Device\\Tape125"},
 801   {"/dev/st126", FHDEV(DEV_TAPE_MAJOR, 126), "\\Device\\Tape126"},
 802   {"/dev/st127", FHDEV(DEV_TAPE_MAJOR, 127), "\\Device\\Tape127"},
 803   {"/dev/tty", FH_TTY, "\\dev\\tty"},
 804   {"/dev/tty0", FHDEV(DEV_TTYS_MAJOR, 0), "\\dev\\tty0"},
 805   {"/dev/tty1", FHDEV(DEV_TTYS_MAJOR, 1), "\\dev\\tty1"},
 806   {"/dev/tty2", FHDEV(DEV_TTYS_MAJOR, 2), "\\dev\\tty2"},
 807   {"/dev/tty3", FHDEV(DEV_TTYS_MAJOR, 3), "\\dev\\tty3"},
 808   {"/dev/tty4", FHDEV(DEV_TTYS_MAJOR, 4), "\\dev\\tty4"},
 809   {"/dev/tty5", FHDEV(DEV_TTYS_MAJOR, 5), "\\dev\\tty5"},
 810   {"/dev/tty6", FHDEV(DEV_TTYS_MAJOR, 6), "\\dev\\tty6"},
 811   {"/dev/tty7", FHDEV(DEV_TTYS_MAJOR, 7), "\\dev\\tty7"},
 812   {"/dev/tty8", FHDEV(DEV_TTYS_MAJOR, 8), "\\dev\\tty8"},
 813   {"/dev/tty9", FHDEV(DEV_TTYS_MAJOR, 9), "\\dev\\tty9"},
 814   {"/dev/tty10", FHDEV(DEV_TTYS_MAJOR, 10), "\\dev\\tty10"},
 815   {"/dev/tty11", FHDEV(DEV_TTYS_MAJOR, 11), "\\dev\\tty11"},
 816   {"/dev/tty12", FHDEV(DEV_TTYS_MAJOR, 12), "\\dev\\tty12"},
 817   {"/dev/tty13", FHDEV(DEV_TTYS_MAJOR, 13), "\\dev\\tty13"},
 818   {"/dev/tty14", FHDEV(DEV_TTYS_MAJOR, 14), "\\dev\\tty14"},
 819   {"/dev/tty15", FHDEV(DEV_TTYS_MAJOR, 15), "\\dev\\tty15"},
 820   {"/dev/tty16", FHDEV(DEV_TTYS_MAJOR, 16), "\\dev\\tty16"},
 821   {"/dev/tty17", FHDEV(DEV_TTYS_MAJOR, 17), "\\dev\\tty17"},
 822   {"/dev/tty18", FHDEV(DEV_TTYS_MAJOR, 18), "\\dev\\tty18"},
 823   {"/dev/tty19", FHDEV(DEV_TTYS_MAJOR, 19), "\\dev\\tty19"},
 824   {"/dev/tty20", FHDEV(DEV_TTYS_MAJOR, 20), "\\dev\\tty20"},
 825   {"/dev/tty21", FHDEV(DEV_TTYS_MAJOR, 21), "\\dev\\tty21"},
 826   {"/dev/tty22", FHDEV(DEV_TTYS_MAJOR, 22), "\\dev\\tty22"},
 827   {"/dev/tty23", FHDEV(DEV_TTYS_MAJOR, 23), "\\dev\\tty23"},
 828   {"/dev/tty24", FHDEV(DEV_TTYS_MAJOR, 24), "\\dev\\tty24"},
 829   {"/dev/tty25", FHDEV(DEV_TTYS_MAJOR, 25), "\\dev\\tty25"},
 830   {"/dev/tty26", FHDEV(DEV_TTYS_MAJOR, 26), "\\dev\\tty26"},
 831   {"/dev/tty27", FHDEV(DEV_TTYS_MAJOR, 27), "\\dev\\tty27"},
 832   {"/dev/tty28", FHDEV(DEV_TTYS_MAJOR, 28), "\\dev\\tty28"},
 833   {"/dev/tty29", FHDEV(DEV_TTYS_MAJOR, 29), "\\dev\\tty29"},
 834   {"/dev/tty30", FHDEV(DEV_TTYS_MAJOR, 30), "\\dev\\tty30"},
 835   {"/dev/tty31", FHDEV(DEV_TTYS_MAJOR, 31), "\\dev\\tty31"},
 836   {"/dev/tty32", FHDEV(DEV_TTYS_MAJOR, 32), "\\dev\\tty32"},
 837   {"/dev/tty33", FHDEV(DEV_TTYS_MAJOR, 33), "\\dev\\tty33"},
 838   {"/dev/tty34", FHDEV(DEV_TTYS_MAJOR, 34), "\\dev\\tty34"},
 839   {"/dev/tty35", FHDEV(DEV_TTYS_MAJOR, 35), "\\dev\\tty35"},
 840   {"/dev/tty36", FHDEV(DEV_TTYS_MAJOR, 36), "\\dev\\tty36"},
 841   {"/dev/tty37", FHDEV(DEV_TTYS_MAJOR, 37), "\\dev\\tty37"},
 842   {"/dev/tty38", FHDEV(DEV_TTYS_MAJOR, 38), "\\dev\\tty38"},
 843   {"/dev/tty39", FHDEV(DEV_TTYS_MAJOR, 39), "\\dev\\tty39"},
 844   {"/dev/tty40", FHDEV(DEV_TTYS_MAJOR, 40), "\\dev\\tty40"},
 845   {"/dev/tty41", FHDEV(DEV_TTYS_MAJOR, 41), "\\dev\\tty41"},
 846   {"/dev/tty42", FHDEV(DEV_TTYS_MAJOR, 42), "\\dev\\tty42"},
 847   {"/dev/tty43", FHDEV(DEV_TTYS_MAJOR, 43), "\\dev\\tty43"},
 848   {"/dev/tty44", FHDEV(DEV_TTYS_MAJOR, 44), "\\dev\\tty44"},
 849   {"/dev/tty45", FHDEV(DEV_TTYS_MAJOR, 45), "\\dev\\tty45"},
 850   {"/dev/tty46", FHDEV(DEV_TTYS_MAJOR, 46), "\\dev\\tty46"},
 851   {"/dev/tty47", FHDEV(DEV_TTYS_MAJOR, 47), "\\dev\\tty47"},
 852   {"/dev/tty48", FHDEV(DEV_TTYS_MAJOR, 48), "\\dev\\tty48"},
 853   {"/dev/tty49", FHDEV(DEV_TTYS_MAJOR, 49), "\\dev\\tty49"},
 854   {"/dev/tty50", FHDEV(DEV_TTYS_MAJOR, 50), "\\dev\\tty50"},
 855   {"/dev/tty51", FHDEV(DEV_TTYS_MAJOR, 51), "\\dev\\tty51"},
 856   {"/dev/tty52", FHDEV(DEV_TTYS_MAJOR, 52), "\\dev\\tty52"},
 857   {"/dev/tty53", FHDEV(DEV_TTYS_MAJOR, 53), "\\dev\\tty53"},
 858   {"/dev/tty54", FHDEV(DEV_TTYS_MAJOR, 54), "\\dev\\tty54"},
 859   {"/dev/tty55", FHDEV(DEV_TTYS_MAJOR, 55), "\\dev\\tty55"},
 860   {"/dev/tty56", FHDEV(DEV_TTYS_MAJOR, 56), "\\dev\\tty56"},
 861   {"/dev/tty57", FHDEV(DEV_TTYS_MAJOR, 57), "\\dev\\tty57"},
 862   {"/dev/tty58", FHDEV(DEV_TTYS_MAJOR, 58), "\\dev\\tty58"},
 863   {"/dev/tty59", FHDEV(DEV_TTYS_MAJOR, 59), "\\dev\\tty59"},
 864   {"/dev/tty60", FHDEV(DEV_TTYS_MAJOR, 60), "\\dev\\tty60"},
 865   {"/dev/tty61", FHDEV(DEV_TTYS_MAJOR, 61), "\\dev\\tty61"},
 866   {"/dev/tty62", FHDEV(DEV_TTYS_MAJOR, 62), "\\dev\\tty62"},
 867   {"/dev/tty63", FHDEV(DEV_TTYS_MAJOR, 63), "\\dev\\tty63"},
 868   {"/dev/ttyS0", FHDEV(DEV_SERIAL_MAJOR, 1), "\\\\.\\com1"},
 869   {"/dev/ttyS1", FHDEV(DEV_SERIAL_MAJOR, 2), "\\\\.\\com2"},
 870   {"/dev/ttyS2", FHDEV(DEV_SERIAL_MAJOR, 3), "\\\\.\\com3"},
 871   {"/dev/ttyS3", FHDEV(DEV_SERIAL_MAJOR, 4), "\\\\.\\com4"},
 872   {"/dev/ttyS4", FHDEV(DEV_SERIAL_MAJOR, 5), "\\\\.\\com5"},
 873   {"/dev/ttyS5", FHDEV(DEV_SERIAL_MAJOR, 6), "\\\\.\\com6"},
 874   {"/dev/ttyS6", FHDEV(DEV_SERIAL_MAJOR, 7), "\\\\.\\com7"},
 875   {"/dev/ttyS7", FHDEV(DEV_SERIAL_MAJOR, 8), "\\\\.\\com8"},
 876   {"/dev/ttyS8", FHDEV(DEV_SERIAL_MAJOR, 9), "\\\\.\\com9"},
 877   {"/dev/ttyS9", FHDEV(DEV_SERIAL_MAJOR, 10), "\\\\.\\com10"},
 878   {"/dev/ttyS10", FHDEV(DEV_SERIAL_MAJOR, 11), "\\\\.\\com11"},
 879   {"/dev/ttyS11", FHDEV(DEV_SERIAL_MAJOR, 12), "\\\\.\\com12"},
 880   {"/dev/ttyS12", FHDEV(DEV_SERIAL_MAJOR, 13), "\\\\.\\com13"},
 881   {"/dev/ttyS13", FHDEV(DEV_SERIAL_MAJOR, 14), "\\\\.\\com14"},
 882   {"/dev/ttyS14", FHDEV(DEV_SERIAL_MAJOR, 15), "\\\\.\\com15"},
 883   {"/dev/ttyS15", FHDEV(DEV_SERIAL_MAJOR, 16), "\\\\.\\com16"},
 884   {"/dev/ttym", FH_TTYM, "\\dev\\ttym"},
 885   {"/dev/urandom", FH_URANDOM, "\\dev\\urandom"},
 886   {"/dev/windows", FH_WINDOWS, "\\dev\\windows"},
 887   {"/dev/zero", FH_ZERO, "\\dev\\zero"}
 888 };
 889
 890 const device *console_dev = dev_storage + 19;
 891 const device *ttym_dev = dev_storage + 830;
 892 const device *ttys_dev = dev_storage + 750;
 893 const device *urandom_dev = dev_storage + 831;
 894
 895
 896 static KR_device_t KR_find_keyword (const char *KR_keyword, int KR_length)
 897 {
 898
 899   switch (KR_length)
 900     {
 901     case 8:
 902       switch (KR_keyword [7])
 903         {
 904         case 'z':
 905           if (strncmp (KR_keyword, "/dev/sdz", 8) == 0)
 906             {
 907 {
 908 return dev_storage + 214;
 909
 910 }
 911             }
 912           else
 913             {
 914 {
 915 return  NULL;
 916
 917 }
 918             }
 919         case 'y':
 920           switch (KR_keyword [5])
 921             {
 922             case 't':
 923               if (strncmp (KR_keyword, "/dev/tty", 8) == 0)
 924                 {
 925 {
 926 return dev_storage + 749;
 927
 928 }
 929                 }
 930               else
 931                 {
 932 {
 933 return  NULL;
 934
 935 }
 936                 }
 937             case 's':
 938               if (strncmp (KR_keyword, "/dev/sdy", 8) == 0)
 939                 {
 940 {
 941 return dev_storage + 213;
 942
 943 }
 944                 }
 945               else
 946                 {
 947 {
 948 return  NULL;
 949
 950 }
 951                 }
 952             default:
 953 {
 954 return  NULL;
 955
 956 }
 957             }
 958         case 'x':
 959           if (strncmp (KR_keyword, "/dev/sdx", 8) == 0)
 960             {
 961 {
 962 return dev_storage + 212;
 963
 964 }
 965             }
 966           else
 967             {
 968 {
 969 return  NULL;
 970
 971 }
 972             }
 973         case 'w':
 974           if (strncmp (KR_keyword, "/dev/sdw", 8) == 0)
 975             {
 976 {
 977 return dev_storage + 211;
 978
 979 }
 980             }
 981           else
 982             {
 983 {
 984 return  NULL;
 985
 986 }
 987             }
 988         case 'v':
 989           if (strncmp (KR_keyword, "/dev/sdv", 8) == 0)
 990             {
 991 {
 992 return dev_storage + 210;
 993
 994 }
 995             }
 996           else
 997             {
 998 {
 999 return  NULL;
1000
1001 }
1002             }
1003         case 'u':
1004           if (strncmp (KR_keyword, "/dev/sdu", 8) == 0)
1005             {
1006 {
1007 return dev_storage + 209;
1008
1009 }
1010             }
1011           else
1012             {
1013 {
1014 return  NULL;
1015
1016 }
1017             }
1018         case 't':
1019           if (strncmp (KR_keyword, "/dev/sdt", 8) == 0)
1020             {
1021 {
1022 return dev_storage + 208;
1023
1024 }
1025             }
1026           else
1027             {
1028 {
1029 return  NULL;
1030
1031 }
1032             }
1033         case 's':
1034           if (strncmp (KR_keyword, "/dev/sds", 8) == 0)
1035             {
1036 {
1037 return dev_storage + 207;
1038
1039 }
1040             }
1041           else
1042             {
1043 {
1044 return  NULL;
1045
1046 }
1047             }
1048         case 'r':
1049           if (strncmp (KR_keyword, "/dev/sdr", 8) == 0)
1050             {
1051 {
1052 return dev_storage + 206;
1053
1054 }
1055             }
1056           else
1057             {
1058 {
1059 return  NULL;
1060
1061 }
1062             }
1063         case 'q':
1064           if (strncmp (KR_keyword, "/dev/sdq", 8) == 0)
1065             {
1066 {
1067 return dev_storage + 205;
1068
1069 }
1070             }
1071           else
1072             {
1073 {
1074 return  NULL;
1075
1076 }
1077             }
1078         case 'p':
1079           switch (KR_keyword [5])
1080             {
1081             case 's':
1082               if (strncmp (KR_keyword, "/dev/sdp", 8) == 0)
1083                 {
1084 {
1085 return dev_storage + 204;
1086
1087 }
1088                 }
1089               else
1090                 {
1091 {
1092 return  NULL;
1093
1094 }
1095                 }
1096             case 'd':
1097               if (strncmp (KR_keyword, "/dev/dsp", 8) == 0)
1098                 {
1099 {
1100 return dev_storage + 20;
1101
1102 }
1103                 }
1104               else
1105                 {
1106 {
1107 return  NULL;
1108
1109 }
1110                 }
1111             default:
1112 {
1113 return  NULL;
1114
1115 }
1116             }
1117         case 'o':
1118           if (strncmp (KR_keyword, "/dev/sdo", 8) == 0)
1119             {
1120 {
1121 return dev_storage + 203;
1122
1123 }
1124             }
1125           else
1126             {
1127 {
1128 return  NULL;
1129
1130 }
1131             }
1132         case 'n':
1133           if (strncmp (KR_keyword, "/dev/sdn", 8) == 0)
1134             {
1135 {
1136 return dev_storage + 202;
1137
1138 }
1139             }
1140           else
1141             {
1142 {
1143 return  NULL;
1144
1145 }
1146             }
1147         case 'm':
1148           switch (KR_keyword [5])
1149             {
1150             case 's':
1151               if (strncmp (KR_keyword, "/dev/sdm", 8) == 0)
1152                 {
1153 {
1154 return dev_storage + 201;
1155
1156 }
1157                 }
1158               else
1159                 {
1160 {
1161 return  NULL;
1162
1163 }
1164                 }
1165             case 'm':
1166               if (strncmp (KR_keyword, "/dev/mem", 8) == 0)
1167                 {
1168 {
1169 return dev_storage + 39;
1170
1171 }
1172                 }
1173               else
1174                 {
1175 {
1176 return  NULL;
1177
1178 }
1179                 }
1180             default:
1181 {
1182 return  NULL;
1183
1184 }
1185             }
1186         case 'l':
1187           if (strncmp (KR_keyword, "/dev/sdl", 8) == 0)
1188             {
1189 {
1190 return dev_storage + 200;
1191
1192 }
1193             }
1194           else
1195             {
1196 {
1197 return  NULL;
1198
1199 }
1200             }
1201         case 'k':
1202           if (strncmp (KR_keyword, "/dev/sdk", 8) == 0)
1203             {
1204 {
1205 return dev_storage + 199;
1206
1207 }
1208             }
1209           else
1210             {
1211 {
1212 return  NULL;
1213
1214 }
1215             }
1216         case 'j':
1217           if (strncmp (KR_keyword, "/dev/sdj", 8) == 0)
1218             {
1219 {
1220 return dev_storage + 198;
1221
1222 }
1223             }
1224           else
1225             {
1226 {
1227 return  NULL;
1228
1229 }
1230             }
1231         case 'i':
1232           if (strncmp (KR_keyword, "/dev/sdi", 8) == 0)
1233             {
1234 {
1235 return dev_storage + 197;
1236
1237 }
1238             }
1239           else
1240             {
1241 {
1242 return  NULL;
1243
1244 }
1245             }
1246         case 'h':
1247           if (strncmp (KR_keyword, "/dev/sdh", 8) == 0)
1248             {
1249 {
1250 return dev_storage + 196;
1251
1252 }
1253             }
1254           else
1255             {
1256 {
1257 return  NULL;
1258
1259 }
1260             }
1261         case 'g':
1262           if (strncmp (KR_keyword, "/dev/sdg", 8) == 0)
1263             {
1264 {
1265 return dev_storage + 195;
1266
1267 }
1268             }
1269           else
1270             {
1271 {
1272 return  NULL;
1273
1274 }
1275             }
1276         case 'f':
1277           if (strncmp (KR_keyword, "/dev/sdf", 8) == 0)
1278             {
1279 {
1280 return dev_storage + 194;
1281
1282 }
1283             }
1284           else
1285             {
1286 {
1287 return  NULL;
1288
1289 }
1290             }
1291         case 'e':
1292           if (strncmp (KR_keyword, "/dev/sde", 8) == 0)
1293             {
1294 {
1295 return dev_storage + 193;
1296
1297 }
1298             }
1299           else
1300             {
1301 {
1302 return  NULL;
1303
1304 }
1305             }
1306         case 'd':
1307           if (strncmp (KR_keyword, "/dev/sdd", 8) == 0)
1308             {
1309 {
1310 return dev_storage + 192;
1311
1312 }
1313             }
1314           else
1315             {
1316 {
1317 return  NULL;
1318
1319 }
1320             }
1321         case 'c':
1322           if (strncmp (KR_keyword, "/dev/sdc", 8) == 0)
1323             {
1324 {
1325 return dev_storage + 191;
1326
1327 }
1328             }
1329           else
1330             {
1331 {
1332 return  NULL;
1333
1334 }
1335             }
1336         case 'b':
1337           if (strncmp (KR_keyword, "/dev/sdb", 8) == 0)
1338             {
1339 {
1340 return dev_storage + 190;
1341
1342 }
1343             }
1344           else
1345             {
1346 {
1347 return  NULL;
1348
1349 }
1350             }
1351         case 'a':
1352           if (strncmp (KR_keyword, "/dev/sda", 8) == 0)
1353             {
1354 {
1355 return dev_storage + 189;
1356
1357 }
1358             }
1359           else
1360             {
1361 {
1362 return  NULL;
1363
1364 }
1365             }
1366         case '9':
1367           switch (KR_keyword [6])
1368             {
1369             case 't':
1370               if (strncmp (KR_keyword, "/dev/st9", 8) == 0)
1371                 {
1372 {
1373 return dev_storage + 630;
1374
1375 }
1376                 }
1377               else
1378                 {
1379 {
1380 return  NULL;
1381
1382 }
1383                 }
1384             case 'r':
1385               if (strncmp (KR_keyword, "/dev/sr9", 8) == 0)
1386                 {
1387 {
1388 return dev_storage + 614;
1389
1390 }
1391                 }
1392               else
1393                 {
1394 {
1395 return  NULL;
1396
1397 }
1398                 }
1399             case 'd':
1400               if (strncmp (KR_keyword, "/dev/fd9", 8) == 0)
1401                 {
1402 {
1403 return dev_storage + 30;
1404
1405 }
1406                 }
1407               else
1408                 {
1409 {
1410 return  NULL;
1411
1412 }
1413                 }
1414             default:
1415 {
1416 return  NULL;
1417
1418 }
1419             }
1420         case '8':
1421           switch (KR_keyword [6])
1422             {
1423             case 't':
1424               if (strncmp (KR_keyword, "/dev/st8", 8) == 0)
1425                 {
1426 {
1427 return dev_storage + 629;
1428
1429 }
1430                 }
1431               else
1432                 {
1433 {
1434 return  NULL;
1435
1436 }
1437                 }
1438             case 'r':
1439               if (strncmp (KR_keyword, "/dev/sr8", 8) == 0)
1440                 {
1441 {
1442 return dev_storage + 613;
1443
1444 }
1445                 }
1446               else
1447                 {
1448 {
1449 return  NULL;
1450
1451 }
1452                 }
1453             case 'd':
1454               if (strncmp (KR_keyword, "/dev/fd8", 8) == 0)
1455                 {
1456 {
1457 return dev_storage + 29;
1458
1459 }
1460                 }
1461               else
1462                 {
1463 {
1464 return  NULL;
1465
1466 }
1467                 }
1468             default:
1469 {
1470 return  NULL;
1471
1472 }
1473             }
1474         case '7':
1475           switch (KR_keyword [6])
1476             {
1477             case 't':
1478               if (strncmp (KR_keyword, "/dev/st7", 8) == 0)
1479                 {
1480 {
1481 return dev_storage + 628;
1482
1483 }
1484                 }
1485               else
1486                 {
1487 {
1488 return  NULL;
1489
1490 }
1491                 }
1492             case 'r':
1493               if (strncmp (KR_keyword, "/dev/sr7", 8) == 0)
1494                 {
1495 {
1496 return dev_storage + 612;
1497
1498 }
1499                 }
1500               else
1501                 {
1502 {
1503 return  NULL;
1504
1505 }
1506                 }
1507             case 'd':
1508               if (strncmp (KR_keyword, "/dev/fd7", 8) == 0)
1509                 {
1510 {
1511 return dev_storage + 28;
1512
1513 }
1514                 }
1515               else
1516                 {
1517 {
1518 return  NULL;
1519
1520 }
1521                 }
1522             default:
1523 {
1524 return  NULL;
1525
1526 }
1527             }
1528         case '6':
1529           switch (KR_keyword [6])
1530             {
1531             case 't':
1532               if (strncmp (KR_keyword, "/dev/st6", 8) == 0)
1533                 {
1534 {
1535 return dev_storage + 627;
1536
1537 }
1538                 }
1539               else
1540                 {
1541 {
1542 return  NULL;
1543
1544 }
1545                 }
1546             case 'r':
1547               if (strncmp (KR_keyword, "/dev/sr6", 8) == 0)
1548                 {
1549 {
1550 return dev_storage + 611;
1551
1552 }
1553                 }
1554               else
1555                 {
1556 {
1557 return  NULL;
1558
1559 }
1560                 }
1561             case 'd':
1562               if (strncmp (KR_keyword, "/dev/fd6", 8) == 0)
1563                 {
1564 {
1565 return dev_storage + 27;
1566
1567 }
1568                 }
1569               else
1570                 {
1571 {
1572 return  NULL;
1573
1574 }
1575                 }
1576             default:
1577 {
1578 return  NULL;
1579
1580 }
1581             }
1582         case '5':
1583           switch (KR_keyword [6])
1584             {
1585             case 't':
1586               if (strncmp (KR_keyword, "/dev/st5", 8) == 0)
1587                 {
1588 {
1589 return dev_storage + 626;
1590
1591 }
1592                 }
1593               else
1594                 {
1595 {
1596 return  NULL;
1597
1598 }
1599                 }
1600             case 'r':
1601               if (strncmp (KR_keyword, "/dev/sr5", 8) == 0)
1602                 {
1603 {
1604 return dev_storage + 610;
1605
1606 }
1607                 }
1608               else
1609                 {
1610 {
1611 return  NULL;
1612
1613 }
1614                 }
1615             case 'd':
1616               if (strncmp (KR_keyword, "/dev/fd5", 8) == 0)
1617                 {
1618 {
1619 return dev_storage + 26;
1620
1621 }
1622                 }
1623               else
1624                 {
1625 {
1626 return  NULL;
1627
1628 }
1629                 }
1630             default:
1631 {
1632 return  NULL;
1633
1634 }
1635             }
1636         case '4':
1637           switch (KR_keyword [6])
1638             {
1639             case 't':
1640               if (strncmp (KR_keyword, "/dev/st4", 8) == 0)
1641                 {
1642 {
1643 return dev_storage + 625;
1644
1645 }
1646                 }
1647               else
1648                 {
1649 {
1650 return  NULL;
1651
1652 }
1653                 }
1654             case 'r':
1655               if (strncmp (KR_keyword, "/dev/sr4", 8) == 0)
1656                 {
1657 {
1658 return dev_storage + 609;
1659
1660 }
1661                 }
1662               else
1663                 {
1664 {
1665 return  NULL;
1666
1667 }
1668                 }
1669             case 'd':
1670               if (strncmp (KR_keyword, "/dev/fd4", 8) == 0)
1671                 {
1672 {
1673 return dev_storage + 25;
1674
1675 }
1676                 }
1677               else
1678                 {
1679 {
1680 return  NULL;
1681
1682 }
1683                 }
1684             default:
1685 {
1686 return  NULL;
1687
1688 }
1689             }
1690         case '3':
1691           switch (KR_keyword [6])
1692             {
1693             case 't':
1694               if (strncmp (KR_keyword, "/dev/st3", 8) == 0)
1695                 {
1696 {
1697 return dev_storage + 624;
1698
1699 }
1700                 }
1701               else
1702                 {
1703 {
1704 return  NULL;
1705
1706 }
1707                 }
1708             case 'r':
1709               if (strncmp (KR_keyword, "/dev/sr3", 8) == 0)
1710                 {
1711 {
1712 return dev_storage + 608;
1713
1714 }
1715                 }
1716               else
1717                 {
1718 {
1719 return  NULL;
1720
1721 }
1722                 }
1723             case 'd':
1724               if (strncmp (KR_keyword, "/dev/fd3", 8) == 0)
1725                 {
1726 {
1727 return dev_storage + 24;
1728
1729 }
1730                 }
1731               else
1732                 {
1733 {
1734 return  NULL;
1735
1736 }
1737                 }
1738             default:
1739 {
1740 return  NULL;
1741
1742 }
1743             }
1744         case '2':
1745           switch (KR_keyword [6])
1746             {
1747             case 't':
1748               if (strncmp (KR_keyword, "/dev/st2", 8) == 0)
1749                 {
1750 {
1751 return dev_storage + 623;
1752
1753 }
1754                 }
1755               else
1756                 {
1757 {
1758 return  NULL;
1759
1760 }
1761                 }
1762             case 'r':
1763               if (strncmp (KR_keyword, "/dev/sr2", 8) == 0)
1764                 {
1765 {
1766 return dev_storage + 607;
1767
1768 }
1769                 }
1770               else
1771                 {
1772 {
1773 return  NULL;
1774
1775 }
1776                 }
1777             case 'd':
1778               if (strncmp (KR_keyword, "/dev/fd2", 8) == 0)
1779                 {
1780 {
1781 return dev_storage + 23;
1782
1783 }
1784                 }
1785               else
1786                 {
1787 {
1788 return  NULL;
1789
1790 }
1791                 }
1792             default:
1793 {
1794 return  NULL;
1795
1796 }
1797             }
1798         case '1':
1799           switch (KR_keyword [6])
1800             {
1801             case 't':
1802               if (strncmp (KR_keyword, "/dev/st1", 8) == 0)
1803                 {
1804 {
1805 return dev_storage + 622;
1806
1807 }
1808                 }
1809               else
1810                 {
1811 {
1812 return  NULL;
1813
1814 }
1815                 }
1816             case 'r':
1817               if (strncmp (KR_keyword, "/dev/sr1", 8) == 0)
1818                 {
1819 {
1820 return dev_storage + 606;
1821
1822 }
1823                 }
1824               else
1825                 {
1826 {
1827 return  NULL;
1828
1829 }
1830                 }
1831             case 'd':
1832               if (strncmp (KR_keyword, "/dev/fd1", 8) == 0)
1833                 {
1834 {
1835 return dev_storage + 22;
1836
1837 }
1838                 }
1839               else
1840                 {
1841 {
1842 return  NULL;
1843
1844 }
1845                 }
1846             default:
1847 {
1848 return  NULL;
1849
1850 }
1851             }
1852         case '0':
1853           switch (KR_keyword [6])
1854             {
1855             case 't':
1856               if (strncmp (KR_keyword, "/dev/st0", 8) == 0)
1857                 {
1858 {
1859 return dev_storage + 621;
1860
1861 }
1862                 }
1863               else
1864                 {
1865 {
1866 return  NULL;
1867
1868 }
1869                 }
1870             case 'r':
1871               if (strncmp (KR_keyword, "/dev/sr0", 8) == 0)
1872                 {
1873 {
1874 return dev_storage + 605;
1875
1876 }
1877                 }
1878               else
1879                 {
1880 {
1881 return  NULL;
1882
1883 }
1884                 }
1885             case 'd':
1886               if (strncmp (KR_keyword, "/dev/fd0", 8) == 0)
1887                 {
1888 {
1889 return dev_storage + 21;
1890
1891 }
1892                 }
1893               else
1894                 {
1895 {
1896 return  NULL;
1897
1898 }
1899                 }
1900             default:
1901 {
1902 return  NULL;
1903
1904 }
1905             }
1906         default:
1907 {
1908 return  NULL;
1909
1910 }
1911         }
1912     case 9:
1913       switch (KR_keyword [8])
1914         {
1915         case 'x':
1916           if (strncmp (KR_keyword, "/dev/ptmx", 9) == 0)
1917             {
1918 {
1919 return dev_storage + 171;
1920
1921 }
1922             }
1923           else
1924             {
1925 {
1926 return  NULL;
1927
1928 }
1929             }
1930         case 't':
1931           if (strncmp (KR_keyword, "/dev/port", 9) == 0)
1932             {
1933 {
1934 return dev_storage + 170;
1935
1936 }
1937             }
1938           else
1939             {
1940 {
1941 return  NULL;
1942
1943 }
1944             }
1945         case 'o':
1946           switch (KR_keyword [5])
1947             {
1948             case 'z':
1949               if (strncmp (KR_keyword, "/dev/zero", 9) == 0)
1950                 {
1951 {
1952 return dev_storage + 833;
1953
1954 }
1955                 }
1956               else
1957                 {
1958 {
1959 return  NULL;
1960
1961 }
1962                 }
1963             case 'f':
1964               if (strncmp (KR_keyword, "/dev/fifo", 9) == 0)
1965                 {
1966 {
1967 return dev_storage + 37;
1968
1969 }
1970                 }
1971               else
1972                 {
1973 {
1974 return  NULL;
1975
1976 }
1977                 }
1978             default:
1979 {
1980 return  NULL;
1981
1982 }
1983             }
1984         case 'm':
1985           switch (KR_keyword [5])
1986             {
1987             case 't':
1988               if (strncmp (KR_keyword, "/dev/ttym", 9) == 0)
1989                 {
1990 {
1991 return dev_storage + 830;
1992
1993 }
1994                 }
1995               else
1996                 {
1997 {
1998 return  NULL;
1999
2000 }
2001                 }
2002             case 'k':
2003               if (strncmp (KR_keyword, "/dev/kmem", 9) == 0)
2004                 {
2005 {
2006 return dev_storage + 38;
2007
2008 }
2009                 }
2010               else
2011                 {
2012 {
2013 return  NULL;
2014
2015 }
2016                 }
2017             default:
2018 {
2019 return  NULL;
2020
2021 }
2022             }
2023         case 'l':
2024           if (strncmp (KR_keyword, "/dev/null", 9) == 0)
2025             {
2026 {
2027 return dev_storage + 168;
2028
2029 }
2030             }
2031           else
2032             {
2033 {
2034 return  NULL;
2035
2036 }
2037             }
2038         case 'e':
2039           if (strncmp (KR_keyword, "/dev/pipe", 9) == 0)
2040             {
2041 {
2042 return dev_storage + 169;
2043
2044 }
2045             }
2046           else
2047             {
2048 {
2049 return  NULL;
2050
2051 }
2052             }
2053         case '9':
2054           switch (KR_keyword [7])
2055             {
2056             case 'z':
2057               if (strncmp (KR_keyword, "/dev/sdz9", 9) == 0)
2058                 {
2059 {
2060 return dev_storage + 598;
2061
2062 }
2063                 }
2064               else
2065                 {
2066 {
2067 return  NULL;
2068
2069 }
2070                 }
2071             case 'y':
2072               switch (KR_keyword [5])
2073                 {
2074                 case 't':
2075                   if (strncmp (KR_keyword, "/dev/tty9", 9) == 0)
2076                     {
2077 {
2078 return dev_storage + 759;
2079
2080 }
2081                     }
2082                   else
2083                     {
2084 {
2085 return  NULL;
2086
2087 }
2088                     }
2089                 case 's':
2090                   if (strncmp (KR_keyword, "/dev/sdy9", 9) == 0)
2091                     {
2092 {
2093 return dev_storage + 583;
2094
2095 }
2096                     }
2097                   else
2098                     {
2099 {
2100 return  NULL;
2101
2102 }
2103                     }
2104                 default:
2105 {
2106 return  NULL;
2107
2108 }
2109                 }
2110             case 'x':
2111               if (strncmp (KR_keyword, "/dev/sdx9", 9) == 0)
2112                 {
2113 {
2114 return dev_storage + 568;
2115
2116 }
2117                 }
2118               else
2119                 {
2120 {
2121 return  NULL;
2122
2123 }
2124                 }
2125             case 'w':
2126               if (strncmp (KR_keyword, "/dev/sdw9", 9) == 0)
2127                 {
2128 {
2129 return dev_storage + 553;
2130
2131 }
2132                 }
2133               else
2134                 {
2135 {
2136 return  NULL;
2137
2138 }
2139                 }
2140             case 'v':
2141               if (strncmp (KR_keyword, "/dev/sdv9", 9) == 0)
2142                 {
2143 {
2144 return dev_storage + 538;
2145
2146 }
2147                 }
2148               else
2149                 {
2150 {
2151 return  NULL;
2152
2153 }
2154                 }
2155             case 'u':
2156               if (strncmp (KR_keyword, "/dev/sdu9", 9) == 0)
2157                 {
2158 {
2159 return dev_storage + 523;
2160
2161 }
2162                 }
2163               else
2164                 {
2165 {
2166 return  NULL;
2167
2168 }
2169                 }
2170             case 't':
2171               switch (KR_keyword [5])
2172                 {
2173                 case 's':
2174                   if (strncmp (KR_keyword, "/dev/sdt9", 9) == 0)
2175                     {
2176 {
2177 return dev_storage + 508;
2178
2179 }
2180                     }
2181                   else
2182                     {
2183 {
2184 return  NULL;
2185
2186 }
2187                     }
2188                 case 'n':
2189                   if (strncmp (KR_keyword, "/dev/nst9", 9) == 0)
2190                     {
2191 {
2192 return dev_storage + 49;
2193
2194 }
2195                     }
2196                   else
2197                     {
2198 {
2199 return  NULL;
2200
2201 }
2202                     }
2203                 default:
2204 {
2205 return  NULL;
2206
2207 }
2208                 }
2209             case 's':
2210               if (strncmp (KR_keyword, "/dev/sds9", 9) == 0)
2211                 {
2212 {
2213 return dev_storage + 493;
2214
2215 }
2216                 }
2217               else
2218                 {
2219 {
2220 return  NULL;
2221
2222 }
2223                 }
2224             case 'r':
2225               if (strncmp (KR_keyword, "/dev/sdr9", 9) == 0)
2226                 {
2227 {
2228 return dev_storage + 478;
2229
2230 }
2231                 }
2232               else
2233                 {
2234 {
2235 return  NULL;
2236
2237 }
2238                 }
2239             case 'q':
2240               if (strncmp (KR_keyword, "/dev/sdq9", 9) == 0)
2241                 {
2242 {
2243 return dev_storage + 463;
2244
2245 }
2246                 }
2247               else
2248                 {
2249 {
2250 return  NULL;
2251
2252 }
2253                 }
2254             case 'p':
2255               if (strncmp (KR_keyword, "/dev/sdp9", 9) == 0)
2256                 {
2257 {
2258 return dev_storage + 448;
2259
2260 }
2261                 }
2262               else
2263                 {
2264 {
2265 return  NULL;
2266
2267 }
2268                 }
2269             case 'o':
2270               if (strncmp (KR_keyword, "/dev/sdo9", 9) == 0)
2271                 {
2272 {
2273 return dev_storage + 433;
2274
2275 }
2276                 }
2277               else
2278                 {
2279 {
2280 return  NULL;
2281
2282 }
2283                 }
2284             case 'n':
2285               if (strncmp (KR_keyword, "/dev/sdn9", 9) == 0)
2286                 {
2287 {
2288 return dev_storage + 418;
2289
2290 }
2291                 }
2292               else
2293                 {
2294 {
2295 return  NULL;
2296
2297 }
2298                 }
2299             case 'm':
2300               switch (KR_keyword [5])
2301                 {
2302                 case 's':
2303                   if (strncmp (KR_keyword, "/dev/sdm9", 9) == 0)
2304                     {
2305 {
2306 return dev_storage + 403;
2307
2308 }
2309                     }
2310                   else
2311                     {
2312 {
2313 return  NULL;
2314
2315 }
2316                     }
2317                 case 'c':
2318                   if (strncmp (KR_keyword, "/dev/com9", 9) == 0)
2319                     {
2320 {
2321 return dev_storage + 9;
2322
2323 }
2324                     }
2325                   else
2326                     {
2327 {
2328 return  NULL;
2329
2330 }
2331                     }
2332                 default:
2333 {
2334 return  NULL;
2335
2336 }
2337                 }
2338             case 'l':
2339               if (strncmp (KR_keyword, "/dev/sdl9", 9) == 0)
2340                 {
2341 {
2342 return dev_storage + 388;
2343
2344 }
2345                 }
2346               else
2347                 {
2348 {
2349 return  NULL;
2350
2351 }
2352                 }
2353             case 'k':
2354               if (strncmp (KR_keyword, "/dev/sdk9", 9) == 0)
2355                 {
2356 {
2357 return dev_storage + 373;
2358
2359 }
2360                 }
2361               else
2362                 {
2363 {
2364 return  NULL;
2365
2366 }
2367                 }
2368             case 'j':
2369               if (strncmp (KR_keyword, "/dev/sdj9", 9) == 0)
2370                 {
2371 {
2372 return dev_storage + 358;
2373
2374 }
2375                 }
2376               else
2377                 {
2378 {
2379 return  NULL;
2380
2381 }
2382                 }
2383             case 'i':
2384               if (strncmp (KR_keyword, "/dev/sdi9", 9) == 0)
2385                 {
2386 {
2387 return dev_storage + 343;
2388
2389 }
2390                 }
2391               else
2392                 {
2393 {
2394 return  NULL;
2395
2396 }
2397                 }
2398             case 'h':
2399               if (strncmp (KR_keyword, "/dev/sdh9", 9) == 0)
2400                 {
2401 {
2402 return dev_storage + 328;
2403
2404 }
2405                 }
2406               else
2407                 {
2408 {
2409 return  NULL;
2410
2411 }
2412                 }
2413             case 'g':
2414               if (strncmp (KR_keyword, "/dev/sdg9", 9) == 0)
2415                 {
2416 {
2417 return dev_storage + 313;
2418
2419 }
2420                 }
2421               else
2422                 {
2423 {
2424 return  NULL;
2425
2426 }
2427                 }
2428             case 'f':
2429               if (strncmp (KR_keyword, "/dev/sdf9", 9) == 0)
2430                 {
2431 {
2432 return dev_storage + 298;
2433
2434 }
2435                 }
2436               else
2437                 {
2438 {
2439 return  NULL;
2440
2441 }
2442                 }
2443             case 'e':
2444               if (strncmp (KR_keyword, "/dev/sde9", 9) == 0)
2445                 {
2446 {
2447 return dev_storage + 283;
2448
2449 }
2450                 }
2451               else
2452                 {
2453 {
2454 return  NULL;
2455
2456 }
2457                 }
2458             case 'd':
2459               switch (KR_keyword [6])
2460                 {
2461                 case 'd':
2462                   if (strncmp (KR_keyword, "/dev/sdd9", 9) == 0)
2463                     {
2464 {
2465 return dev_storage + 268;
2466
2467 }
2468                     }
2469                   else
2470                     {
2471 {
2472 return  NULL;
2473
2474 }
2475                     }
2476                 case 'c':
2477                   if (strncmp (KR_keyword, "/dev/scd9", 9) == 0)
2478                     {
2479 {
2480 return dev_storage + 182;
2481
2482 }
2483                     }
2484                   else
2485                     {
2486 {
2487 return  NULL;
2488
2489 }
2490                     }
2491                 default:
2492 {
2493 return  NULL;
2494
2495 }
2496                 }
2497             case 'c':
2498               if (strncmp (KR_keyword, "/dev/sdc9", 9) == 0)
2499                 {
2500 {
2501 return dev_storage + 253;
2502
2503 }
2504                 }
2505               else
2506                 {
2507 {
2508 return  NULL;
2509
2510 }
2511                 }
2512             case 'b':
2513               if (strncmp (KR_keyword, "/dev/sdb9", 9) == 0)
2514                 {
2515 {
2516 return dev_storage + 238;
2517
2518 }
2519                 }
2520               else
2521                 {
2522 {
2523 return  NULL;
2524
2525 }
2526                 }
2527             case 'a':
2528               if (strncmp (KR_keyword, "/dev/sda9", 9) == 0)
2529                 {
2530 {
2531 return dev_storage + 223;
2532
2533 }
2534                 }
2535               else
2536                 {
2537 {
2538 return  NULL;
2539
2540 }
2541                 }
2542             case '9':
2543               if (strncmp (KR_keyword, "/dev/st99", 9) == 0)
2544                 {
2545 {
2546 return dev_storage + 720;
2547
2548 }
2549                 }
2550               else
2551                 {
2552 {
2553 return  NULL;
2554
2555 }
2556                 }
2557             case '8':
2558               if (strncmp (KR_keyword, "/dev/st89", 9) == 0)
2559                 {
2560 {
2561 return dev_storage + 710;
2562
2563 }
2564                 }
2565               else
2566                 {
2567 {
2568 return  NULL;
2569
2570 }
2571                 }
2572             case '7':
2573               if (strncmp (KR_keyword, "/dev/st79", 9) == 0)
2574                 {
2575 {
2576 return dev_storage + 700;
2577
2578 }
2579                 }
2580               else
2581                 {
2582 {
2583 return  NULL;
2584
2585 }
2586                 }
2587             case '6':
2588               if (strncmp (KR_keyword, "/dev/st69", 9) == 0)
2589                 {
2590 {
2591 return dev_storage + 690;
2592
2593 }
2594                 }
2595               else
2596                 {
2597 {
2598 return  NULL;
2599
2600 }
2601                 }
2602             case '5':
2603               if (strncmp (KR_keyword, "/dev/st59", 9) == 0)
2604                 {
2605 {
2606 return dev_storage + 680;
2607
2608 }
2609                 }
2610               else
2611                 {
2612 {
2613 return  NULL;
2614
2615 }
2616                 }
2617             case '4':
2618               if (strncmp (KR_keyword, "/dev/st49", 9) == 0)
2619                 {
2620 {
2621 return dev_storage + 670;
2622
2623 }
2624                 }
2625               else
2626                 {
2627 {
2628 return  NULL;
2629
2630 }
2631                 }
2632             case '3':
2633               if (strncmp (KR_keyword, "/dev/st39", 9) == 0)
2634                 {
2635 {
2636 return dev_storage + 660;
2637
2638 }
2639                 }
2640               else
2641                 {
2642 {
2643 return  NULL;
2644
2645 }
2646                 }
2647             case '2':
2648               if (strncmp (KR_keyword, "/dev/st29", 9) == 0)
2649                 {
2650 {
2651 return dev_storage + 650;
2652
2653 }
2654                 }
2655               else
2656                 {
2657 {
2658 return  NULL;
2659
2660 }
2661                 }
2662             case '1':
2663               if (strncmp (KR_keyword, "/dev/st19", 9) == 0)
2664                 {
2665 {
2666 return dev_storage + 640;
2667
2668 }
2669                 }
2670               else
2671                 {
2672 {
2673 return  NULL;
2674
2675 }
2676                 }
2677             default:
2678 {
2679 return  NULL;
2680
2681 }
2682             }
2683         case '8':
2684           switch (KR_keyword [7])
2685             {
2686             case 'z':
2687               if (strncmp (KR_keyword, "/dev/sdz8", 9) == 0)
2688                 {
2689 {
2690 return dev_storage + 597;
2691
2692 }
2693                 }
2694               else
2695                 {
2696 {
2697 return  NULL;
2698
2699 }
2700                 }
2701             case 'y':
2702               switch (KR_keyword [5])
2703                 {
2704                 case 't':
2705                   if (strncmp (KR_keyword, "/dev/tty8", 9) == 0)
2706                     {
2707 {
2708 return dev_storage + 758;
2709
2710 }
2711                     }
2712                   else
2713                     {
2714 {
2715 return  NULL;
2716
2717 }
2718                     }
2719                 case 's':
2720                   if (strncmp (KR_keyword, "/dev/sdy8", 9) == 0)
2721                     {
2722 {
2723 return dev_storage + 582;
2724
2725 }
2726                     }
2727                   else
2728                     {
2729 {
2730 return  NULL;
2731
2732 }
2733                     }
2734                 default:
2735 {
2736 return  NULL;
2737
2738 }
2739                 }
2740             case 'x':
2741               if (strncmp (KR_keyword, "/dev/sdx8", 9) == 0)
2742                 {
2743 {
2744 return dev_storage + 567;
2745
2746 }
2747                 }
2748               else
2749                 {
2750 {
2751 return  NULL;
2752
2753 }
2754                 }
2755             case 'w':
2756               if (strncmp (KR_keyword, "/dev/sdw8", 9) == 0)
2757                 {
2758 {
2759 return dev_storage + 552;
2760
2761 }
2762                 }
2763               else
2764                 {
2765 {
2766 return  NULL;
2767
2768 }
2769                 }
2770             case 'v':
2771               if (strncmp (KR_keyword, "/dev/sdv8", 9) == 0)
2772                 {
2773 {
2774 return dev_storage + 537;
2775
2776 }
2777                 }
2778               else
2779                 {
2780 {
2781 return  NULL;
2782
2783 }
2784                 }
2785             case 'u':
2786               if (strncmp (KR_keyword, "/dev/sdu8", 9) == 0)
2787                 {
2788 {
2789 return dev_storage + 522;
2790
2791 }
2792                 }
2793               else
2794                 {
2795 {
2796 return  NULL;
2797
2798 }
2799                 }
2800             case 't':
2801               switch (KR_keyword [5])
2802                 {
2803                 case 's':
2804                   if (strncmp (KR_keyword, "/dev/sdt8", 9) == 0)
2805                     {
2806 {
2807 return dev_storage + 507;
2808
2809 }
2810                     }
2811                   else
2812                     {
2813 {
2814 return  NULL;
2815
2816 }
2817                     }
2818                 case 'n':
2819                   if (strncmp (KR_keyword, "/dev/nst8", 9) == 0)
2820                     {
2821 {
2822 return dev_storage + 48;
2823
2824 }
2825                     }
2826                   else
2827                     {
2828 {
2829 return  NULL;
2830
2831 }
2832                     }
2833                 default:
2834 {
2835 return  NULL;
2836
2837 }
2838                 }
2839             case 's':
2840               if (strncmp (KR_keyword, "/dev/sds8", 9) == 0)
2841                 {
2842 {
2843 return dev_storage + 492;
2844
2845 }
2846                 }
2847               else
2848                 {
2849 {
2850 return  NULL;
2851
2852 }
2853                 }
2854             case 'r':
2855               if (strncmp (KR_keyword, "/dev/sdr8", 9) == 0)
2856                 {
2857 {
2858 return dev_storage + 477;
2859
2860 }
2861                 }
2862               else
2863                 {
2864 {
2865 return  NULL;
2866
2867 }
2868                 }
2869             case 'q':
2870               if (strncmp (KR_keyword, "/dev/sdq8", 9) == 0)
2871                 {
2872 {
2873 return dev_storage + 462;
2874
2875 }
2876                 }
2877               else
2878                 {
2879 {
2880 return  NULL;
2881
2882 }
2883                 }
2884             case 'p':
2885               if (strncmp (KR_keyword, "/dev/sdp8", 9) == 0)
2886                 {
2887 {
2888 return dev_storage + 447;
2889
2890 }
2891                 }
2892               else
2893                 {
2894 {
2895 return  NULL;
2896
2897 }
2898                 }
2899             case 'o':
2900               if (strncmp (KR_keyword, "/dev/sdo8", 9) == 0)
2901                 {
2902 {
2903 return dev_storage + 432;
2904
2905 }
2906                 }
2907               else
2908                 {
2909 {
2910 return  NULL;
2911
2912 }
2913                 }
2914             case 'n':
2915               if (strncmp (KR_keyword, "/dev/sdn8", 9) == 0)
2916                 {
2917 {
2918 return dev_storage + 417;
2919
2920 }
2921                 }
2922               else
2923                 {
2924 {
2925 return  NULL;
2926
2927 }
2928                 }
2929             case 'm':
2930               switch (KR_keyword [5])
2931                 {
2932                 case 's':
2933                   if (strncmp (KR_keyword, "/dev/sdm8", 9) == 0)
2934                     {
2935 {
2936 return dev_storage + 402;
2937
2938 }
2939                     }
2940                   else
2941                     {
2942 {
2943 return  NULL;
2944
2945 }
2946                     }
2947                 case 'c':
2948                   if (strncmp (KR_keyword, "/dev/com8", 9) == 0)
2949                     {
2950 {
2951 return dev_storage + 8;
2952
2953 }
2954                     }
2955                   else
2956                     {
2957 {
2958 return  NULL;
2959
2960 }
2961                     }
2962                 default:
2963 {
2964 return  NULL;
2965
2966 }
2967                 }
2968             case 'l':
2969               if (strncmp (KR_keyword, "/dev/sdl8", 9) == 0)
2970                 {
2971 {
2972 return dev_storage + 387;
2973
2974 }
2975                 }
2976               else
2977                 {
2978 {
2979 return  NULL;
2980
2981 }
2982                 }
2983             case 'k':
2984               if (strncmp (KR_keyword, "/dev/sdk8", 9) == 0)
2985                 {
2986 {
2987 return dev_storage + 372;
2988
2989 }
2990                 }
2991               else
2992                 {
2993 {
2994 return  NULL;
2995
2996 }
2997                 }
2998             case 'j':
2999               if (strncmp (KR_keyword, "/dev/sdj8", 9) == 0)
3000                 {
3001 {
3002 return dev_storage + 357;
3003
3004 }
3005                 }
3006               else
3007                 {
3008 {
3009 return  NULL;
3010
3011 }
3012                 }
3013             case 'i':
3014               if (strncmp (KR_keyword, "/dev/sdi8", 9) == 0)
3015                 {
3016 {
3017 return dev_storage + 342;
3018
3019 }
3020                 }
3021               else
3022                 {
3023 {
3024 return  NULL;
3025
3026 }
3027                 }
3028             case 'h':
3029               if (strncmp (KR_keyword, "/dev/sdh8", 9) == 0)
3030                 {
3031 {
3032 return dev_storage + 327;
3033
3034 }
3035                 }
3036               else
3037                 {
3038 {
3039 return  NULL;
3040
3041 }
3042                 }
3043             case 'g':
3044               if (strncmp (KR_keyword, "/dev/sdg8", 9) == 0)
3045                 {
3046 {
3047 return dev_storage + 312;
3048
3049 }
3050                 }
3051               else
3052                 {
3053 {
3054 return  NULL;
3055
3056 }
3057                 }
3058             case 'f':
3059               if (strncmp (KR_keyword, "/dev/sdf8", 9) == 0)
3060                 {
3061 {
3062 return dev_storage + 297;
3063
3064 }
3065                 }
3066               else
3067                 {
3068 {
3069 return  NULL;
3070
3071 }
3072                 }
3073             case 'e':
3074               if (strncmp (KR_keyword, "/dev/sde8", 9) == 0)
3075                 {
3076 {
3077 return dev_storage + 282;
3078
3079 }
3080                 }
3081               else
3082                 {
3083 {
3084 return  NULL;
3085
3086 }
3087                 }
3088             case 'd':
3089               switch (KR_keyword [6])
3090                 {
3091                 case 'd':
3092                   if (strncmp (KR_keyword, "/dev/sdd8", 9) == 0)
3093                     {
3094 {
3095 return dev_storage + 267;
3096
3097 }
3098                     }
3099                   else
3100                     {
3101 {
3102 return  NULL;
3103
3104 }
3105                     }
3106                 case 'c':
3107                   if (strncmp (KR_keyword, "/dev/scd8", 9) == 0)
3108                     {
3109 {
3110 return dev_storage + 181;
3111
3112 }
3113                     }
3114                   else
3115                     {
3116 {
3117 return  NULL;
3118
3119 }
3120                     }
3121                 default:
3122 {
3123 return  NULL;
3124
3125 }
3126                 }
3127             case 'c':
3128               if (strncmp (KR_keyword, "/dev/sdc8", 9) == 0)
3129                 {
3130 {
3131 return dev_storage + 252;
3132
3133 }
3134                 }
3135               else
3136                 {
3137 {
3138 return  NULL;
3139
3140 }
3141                 }
3142             case 'b':
3143               if (strncmp (KR_keyword, "/dev/sdb8", 9) == 0)
3144                 {
3145 {
3146 return dev_storage + 237;
3147
3148 }
3149                 }
3150               else
3151                 {
3152 {
3153 return  NULL;
3154
3155 }
3156                 }
3157             case 'a':
3158               if (strncmp (KR_keyword, "/dev/sda8", 9) == 0)
3159                 {
3160 {
3161 return dev_storage + 222;
3162
3163 }
3164                 }
3165               else
3166                 {
3167 {
3168 return  NULL;
3169
3170 }
3171                 }
3172             case '9':
3173               if (strncmp (KR_keyword, "/dev/st98", 9) == 0)
3174                 {
3175 {
3176 return dev_storage + 719;
3177
3178 }
3179                 }
3180               else
3181                 {
3182 {
3183 return  NULL;
3184
3185 }
3186                 }
3187             case '8':
3188               if (strncmp (KR_keyword, "/dev/st88", 9) == 0)
3189                 {
3190 {
3191 return dev_storage + 709;
3192
3193 }
3194                 }
3195               else
3196                 {
3197 {
3198 return  NULL;
3199
3200 }
3201                 }
3202             case '7':
3203               if (strncmp (KR_keyword, "/dev/st78", 9) == 0)
3204                 {
3205 {
3206 return dev_storage + 699;
3207
3208 }
3209                 }
3210               else
3211                 {
3212 {
3213 return  NULL;
3214
3215 }
3216                 }
3217             case '6':
3218               if (strncmp (KR_keyword, "/dev/st68", 9) == 0)
3219                 {
3220 {
3221 return dev_storage + 689;
3222
3223 }
3224                 }
3225               else
3226                 {
3227 {
3228 return  NULL;
3229
3230 }
3231                 }
3232             case '5':
3233               if (strncmp (KR_keyword, "/dev/st58", 9) == 0)
3234                 {
3235 {
3236 return dev_storage + 679;
3237
3238 }
3239                 }
3240               else
3241                 {
3242 {
3243 return  NULL;
3244
3245 }
3246                 }
3247             case '4':
3248               if (strncmp (KR_keyword, "/dev/st48", 9) == 0)
3249                 {
3250 {
3251 return dev_storage + 669;
3252
3253 }
3254                 }
3255               else
3256                 {
3257 {
3258 return  NULL;
3259
3260 }
3261                 }
3262             case '3':
3263               if (strncmp (KR_keyword, "/dev/st38", 9) == 0)
3264                 {
3265 {
3266 return dev_storage + 659;
3267
3268 }
3269                 }
3270               else
3271                 {
3272 {
3273 return  NULL;
3274
3275 }
3276                 }
3277             case '2':
3278               if (strncmp (KR_keyword, "/dev/st28", 9) == 0)
3279                 {
3280 {
3281 return dev_storage + 649;
3282
3283 }
3284                 }
3285               else
3286                 {
3287 {
3288 return  NULL;
3289
3290 }
3291                 }
3292             case '1':
3293               if (strncmp (KR_keyword, "/dev/st18", 9) == 0)
3294                 {
3295 {
3296 return dev_storage + 639;
3297
3298 }
3299                 }
3300               else
3301                 {
3302 {
3303 return  NULL;
3304
3305 }
3306                 }
3307             default:
3308 {
3309 return  NULL;
3310
3311 }
3312             }
3313         case '7':
3314           switch (KR_keyword [7])
3315             {
3316             case 'z':
3317               if (strncmp (KR_keyword, "/dev/sdz7", 9) == 0)
3318                 {
3319 {
3320 return dev_storage + 596;
3321
3322 }
3323                 }
3324               else
3325                 {
3326 {
3327 return  NULL;
3328
3329 }
3330                 }
3331             case 'y':
3332               switch (KR_keyword [5])
3333                 {
3334                 case 't':
3335                   if (strncmp (KR_keyword, "/dev/tty7", 9) == 0)
3336                     {
3337 {
3338 return dev_storage + 757;
3339
3340 }
3341                     }
3342                   else
3343                     {
3344 {
3345 return  NULL;
3346
3347 }
3348                     }
3349                 case 's':
3350                   if (strncmp (KR_keyword, "/dev/sdy7", 9) == 0)
3351                     {
3352 {
3353 return dev_storage + 581;
3354
3355 }
3356                     }
3357                   else
3358                     {
3359 {
3360 return  NULL;
3361
3362 }
3363                     }
3364                 default:
3365 {
3366 return  NULL;
3367
3368 }
3369                 }
3370             case 'x':
3371               if (strncmp (KR_keyword, "/dev/sdx7", 9) == 0)
3372                 {
3373 {
3374 return dev_storage + 566;
3375
3376 }
3377                 }
3378               else
3379                 {
3380 {
3381 return  NULL;
3382
3383 }
3384                 }
3385             case 'w':
3386               if (strncmp (KR_keyword, "/dev/sdw7", 9) == 0)
3387                 {
3388 {
3389 return dev_storage + 551;
3390
3391 }
3392                 }
3393               else
3394                 {
3395 {
3396 return  NULL;
3397
3398 }
3399                 }
3400             case 'v':
3401               if (strncmp (KR_keyword, "/dev/sdv7", 9) == 0)
3402                 {
3403 {
3404 return dev_storage + 536;
3405
3406 }
3407                 }
3408               else
3409                 {
3410 {
3411 return  NULL;
3412
3413 }
3414                 }
3415             case 'u':
3416               if (strncmp (KR_keyword, "/dev/sdu7", 9) == 0)
3417                 {
3418 {
3419 return dev_storage + 521;
3420
3421 }
3422                 }
3423               else
3424                 {
3425 {
3426 return  NULL;
3427
3428 }
3429                 }
3430             case 't':
3431               switch (KR_keyword [5])
3432                 {
3433                 case 's':
3434                   if (strncmp (KR_keyword, "/dev/sdt7", 9) == 0)
3435                     {
3436 {
3437 return dev_storage + 506;
3438
3439 }
3440                     }
3441                   else
3442                     {
3443 {
3444 return  NULL;
3445
3446 }
3447                     }
3448                 case 'n':
3449                   if (strncmp (KR_keyword, "/dev/nst7", 9) == 0)
3450                     {
3451 {
3452 return dev_storage + 47;
3453
3454 }
3455                     }
3456                   else
3457                     {
3458 {
3459 return  NULL;
3460
3461 }
3462                     }
3463                 default:
3464 {
3465 return  NULL;
3466
3467 }
3468                 }
3469             case 's':
3470               if (strncmp (KR_keyword, "/dev/sds7", 9) == 0)
3471                 {
3472 {
3473 return dev_storage + 491;
3474
3475 }
3476                 }
3477               else
3478                 {
3479 {
3480 return  NULL;
3481
3482 }
3483                 }
3484             case 'r':
3485               if (strncmp (KR_keyword, "/dev/sdr7", 9) == 0)
3486                 {
3487 {
3488 return dev_storage + 476;
3489
3490 }
3491                 }
3492               else
3493                 {
3494 {
3495 return  NULL;
3496
3497 }
3498                 }
3499             case 'q':
3500               if (strncmp (KR_keyword, "/dev/sdq7", 9) == 0)
3501                 {
3502 {
3503 return dev_storage + 461;
3504
3505 }
3506                 }
3507               else
3508                 {
3509 {
3510 return  NULL;
3511
3512 }
3513                 }
3514             case 'p':
3515               if (strncmp (KR_keyword, "/dev/sdp7", 9) == 0)
3516                 {
3517 {
3518 return dev_storage + 446;
3519
3520 }
3521                 }
3522               else
3523                 {
3524 {
3525 return  NULL;
3526
3527 }
3528                 }
3529             case 'o':
3530               if (strncmp (KR_keyword, "/dev/sdo7", 9) == 0)
3531                 {
3532 {
3533 return dev_storage + 431;
3534
3535 }
3536                 }
3537               else
3538                 {
3539 {
3540 return  NULL;
3541
3542 }
3543                 }
3544             case 'n':
3545               if (strncmp (KR_keyword, "/dev/sdn7", 9) == 0)
3546                 {
3547 {
3548 return dev_storage + 416;
3549
3550 }
3551                 }
3552               else
3553                 {
3554 {
3555 return  NULL;
3556
3557 }
3558                 }
3559             case 'm':
3560               switch (KR_keyword [5])
3561                 {
3562                 case 's':
3563                   if (strncmp (KR_keyword, "/dev/sdm7", 9) == 0)
3564                     {
3565 {
3566 return dev_storage + 401;
3567
3568 }
3569                     }
3570                   else
3571                     {
3572 {
3573 return  NULL;
3574
3575 }
3576                     }
3577                 case 'c':
3578                   if (strncmp (KR_keyword, "/dev/com7", 9) == 0)
3579                     {
3580 {
3581 return dev_storage + 7;
3582
3583 }
3584                     }
3585                   else
3586                     {
3587 {
3588 return  NULL;
3589
3590 }
3591                     }
3592                 default:
3593 {
3594 return  NULL;
3595
3596 }
3597                 }
3598             case 'l':
3599               if (strncmp (KR_keyword, "/dev/sdl7", 9) == 0)
3600                 {
3601 {
3602 return dev_storage + 386;
3603
3604 }
3605                 }
3606               else
3607                 {
3608 {
3609 return  NULL;
3610
3611 }
3612                 }
3613             case 'k':
3614               if (strncmp (KR_keyword, "/dev/sdk7", 9) == 0)
3615                 {
3616 {
3617 return dev_storage + 371;
3618
3619 }
3620                 }
3621               else
3622                 {
3623 {
3624 return  NULL;
3625
3626 }
3627                 }
3628             case 'j':
3629               if (strncmp (KR_keyword, "/dev/sdj7", 9) == 0)
3630                 {
3631 {
3632 return dev_storage + 356;
3633
3634 }
3635                 }
3636               else
3637                 {
3638 {
3639 return  NULL;
3640
3641 }
3642                 }
3643             case 'i':
3644               if (strncmp (KR_keyword, "/dev/sdi7", 9) == 0)
3645                 {
3646 {
3647 return dev_storage + 341;
3648
3649 }
3650                 }
3651               else
3652                 {
3653 {
3654 return  NULL;
3655
3656 }
3657                 }
3658             case 'h':
3659               if (strncmp (KR_keyword, "/dev/sdh7", 9) == 0)
3660                 {
3661 {
3662 return dev_storage + 326;
3663
3664 }
3665                 }
3666               else
3667                 {
3668 {
3669 return  NULL;
3670
3671 }
3672                 }
3673             case 'g':
3674               if (strncmp (KR_keyword, "/dev/sdg7", 9) == 0)
3675                 {
3676 {
3677 return dev_storage + 311;
3678
3679 }
3680                 }
3681               else
3682                 {
3683 {
3684 return  NULL;
3685
3686 }
3687                 }
3688             case 'f':
3689               if (strncmp (KR_keyword, "/dev/sdf7", 9) == 0)
3690                 {
3691 {
3692 return dev_storage + 296;
3693
3694 }
3695                 }
3696               else
3697                 {
3698 {
3699 return  NULL;
3700
3701 }
3702                 }
3703             case 'e':
3704               if (strncmp (KR_keyword, "/dev/sde7", 9) == 0)
3705                 {
3706 {
3707 return dev_storage + 281;
3708
3709 }
3710                 }
3711               else
3712                 {
3713 {
3714 return  NULL;
3715
3716 }
3717                 }
3718             case 'd':
3719               switch (KR_keyword [6])
3720                 {
3721                 case 'd':
3722                   if (strncmp (KR_keyword, "/dev/sdd7", 9) == 0)
3723                     {
3724 {
3725 return dev_storage + 266;
3726
3727 }
3728                     }
3729                   else
3730                     {
3731 {
3732 return  NULL;
3733
3734 }
3735                     }
3736                 case 'c':
3737                   if (strncmp (KR_keyword, "/dev/scd7", 9) == 0)
3738                     {
3739 {
3740 return dev_storage + 180;
3741
3742 }
3743                     }
3744                   else
3745                     {
3746 {
3747 return  NULL;
3748
3749 }
3750                     }
3751                 default:
3752 {
3753 return  NULL;
3754
3755 }
3756                 }
3757             case 'c':
3758               if (strncmp (KR_keyword, "/dev/sdc7", 9) == 0)
3759                 {
3760 {
3761 return dev_storage + 251;
3762
3763 }
3764                 }
3765               else
3766                 {
3767 {
3768 return  NULL;
3769
3770 }
3771                 }
3772             case 'b':
3773               if (strncmp (KR_keyword, "/dev/sdb7", 9) == 0)
3774                 {
3775 {
3776 return dev_storage + 236;
3777
3778 }
3779                 }
3780               else
3781                 {
3782 {
3783 return  NULL;
3784
3785 }
3786                 }
3787             case 'a':
3788               if (strncmp (KR_keyword, "/dev/sda7", 9) == 0)
3789                 {
3790 {
3791 return dev_storage + 221;
3792
3793 }
3794                 }
3795               else
3796                 {
3797 {
3798 return  NULL;
3799
3800 }
3801                 }
3802             case '9':
3803               if (strncmp (KR_keyword, "/dev/st97", 9) == 0)
3804                 {
3805 {
3806 return dev_storage + 718;
3807
3808 }
3809                 }
3810               else
3811                 {
3812 {
3813 return  NULL;
3814
3815 }
3816                 }
3817             case '8':
3818               if (strncmp (KR_keyword, "/dev/st87", 9) == 0)
3819                 {
3820 {
3821 return dev_storage + 708;
3822
3823 }
3824                 }
3825               else
3826                 {
3827 {
3828 return  NULL;
3829
3830 }
3831                 }
3832             case '7':
3833               if (strncmp (KR_keyword, "/dev/st77", 9) == 0)
3834                 {
3835 {
3836 return dev_storage + 698;
3837
3838 }
3839                 }
3840               else
3841                 {
3842 {
3843 return  NULL;
3844
3845 }
3846                 }
3847             case '6':
3848               if (strncmp (KR_keyword, "/dev/st67", 9) == 0)
3849                 {
3850 {
3851 return dev_storage + 688;
3852
3853 }
3854                 }
3855               else
3856                 {
3857 {
3858 return  NULL;
3859
3860 }
3861                 }
3862             case '5':
3863               if (strncmp (KR_keyword, "/dev/st57", 9) == 0)
3864                 {
3865 {
3866 return dev_storage + 678;
3867
3868 }
3869                 }
3870               else
3871                 {
3872 {
3873 return  NULL;
3874
3875 }
3876                 }
3877             case '4':
3878               if (strncmp (KR_keyword, "/dev/st47", 9) == 0)
3879                 {
3880 {
3881 return dev_storage + 668;
3882
3883 }
3884                 }
3885               else
3886                 {
3887 {
3888 return  NULL;
3889
3890 }
3891                 }
3892             case '3':
3893               if (strncmp (KR_keyword, "/dev/st37", 9) == 0)
3894                 {
3895 {
3896 return dev_storage + 658;
3897
3898 }
3899                 }
3900               else
3901                 {
3902 {
3903 return  NULL;
3904
3905 }
3906                 }
3907             case '2':
3908               if (strncmp (KR_keyword, "/dev/st27", 9) == 0)
3909                 {
3910 {
3911 return dev_storage + 648;
3912
3913 }
3914                 }
3915               else
3916                 {
3917 {
3918 return  NULL;
3919
3920 }
3921                 }
3922             case '1':
3923               if (strncmp (KR_keyword, "/dev/st17", 9) == 0)
3924                 {
3925 {
3926 return dev_storage + 638;
3927
3928 }
3929                 }
3930               else
3931                 {
3932 {
3933 return  NULL;
3934
3935 }
3936                 }
3937             default:
3938 {
3939 return  NULL;
3940
3941 }
3942             }
3943         case '6':
3944           switch (KR_keyword [7])
3945             {
3946             case 'z':
3947               if (strncmp (KR_keyword, "/dev/sdz6", 9) == 0)
3948                 {
3949 {
3950 return dev_storage + 595;
3951
3952 }
3953                 }
3954               else
3955                 {
3956 {
3957 return  NULL;
3958
3959 }
3960                 }
3961             case 'y':
3962               switch (KR_keyword [5])
3963                 {
3964                 case 't':
3965                   if (strncmp (KR_keyword, "/dev/tty6", 9) == 0)
3966                     {
3967 {
3968 return dev_storage + 756;
3969
3970 }
3971                     }
3972                   else
3973                     {
3974 {
3975 return  NULL;
3976
3977 }
3978                     }
3979                 case 's':
3980                   if (strncmp (KR_keyword, "/dev/sdy6", 9) == 0)
3981                     {
3982 {
3983 return dev_storage + 580;
3984
3985 }
3986                     }
3987                   else
3988                     {
3989 {
3990 return  NULL;
3991
3992 }
3993                     }
3994                 default:
3995 {
3996 return  NULL;
3997
3998 }
3999                 }
4000             case 'x':
4001               if (strncmp (KR_keyword, "/dev/sdx6", 9) == 0)
4002                 {
4003 {
4004 return dev_storage + 565;
4005
4006 }
4007                 }
4008               else
4009                 {
4010 {
4011 return  NULL;
4012
4013 }
4014                 }
4015             case 'w':
4016               if (strncmp (KR_keyword, "/dev/sdw6", 9) == 0)
4017                 {
4018 {
4019 return dev_storage + 550;
4020
4021 }
4022                 }
4023               else
4024                 {
4025 {
4026 return  NULL;
4027
4028 }
4029                 }
4030             case 'v':
4031               if (strncmp (KR_keyword, "/dev/sdv6", 9) == 0)
4032                 {
4033 {
4034 return dev_storage + 535;
4035
4036 }
4037                 }
4038               else
4039                 {
4040 {
4041 return  NULL;
4042
4043 }
4044                 }
4045             case 'u':
4046               if (strncmp (KR_keyword, "/dev/sdu6", 9) == 0)
4047                 {
4048 {
4049 return dev_storage + 520;
4050
4051 }
4052                 }
4053               else
4054                 {
4055 {
4056 return  NULL;
4057
4058 }
4059                 }
4060             case 't':
4061               switch (KR_keyword [5])
4062                 {
4063                 case 's':
4064                   if (strncmp (KR_keyword, "/dev/sdt6", 9) == 0)
4065                     {
4066 {
4067 return dev_storage + 505;
4068
4069 }
4070                     }
4071                   else
4072                     {
4073 {
4074 return  NULL;
4075
4076 }
4077                     }
4078                 case 'n':
4079                   if (strncmp (KR_keyword, "/dev/nst6", 9) == 0)
4080                     {
4081 {
4082 return dev_storage + 46;
4083
4084 }
4085                     }
4086                   else
4087                     {
4088 {
4089 return  NULL;
4090
4091 }
4092                     }
4093                 default:
4094 {
4095 return  NULL;
4096
4097 }
4098                 }
4099             case 's':
4100               if (strncmp (KR_keyword, "/dev/sds6", 9) == 0)
4101                 {
4102 {
4103 return dev_storage + 490;
4104
4105 }
4106                 }
4107               else
4108                 {
4109 {
4110 return  NULL;
4111
4112 }
4113                 }
4114             case 'r':
4115               if (strncmp (KR_keyword, "/dev/sdr6", 9) == 0)
4116                 {
4117 {
4118 return dev_storage + 475;
4119
4120 }
4121                 }
4122               else
4123                 {
4124 {
4125 return  NULL;
4126
4127 }
4128                 }
4129             case 'q':
4130               if (strncmp (KR_keyword, "/dev/sdq6", 9) == 0)
4131                 {
4132 {
4133 return dev_storage + 460;
4134
4135 }
4136                 }
4137               else
4138                 {
4139 {
4140 return  NULL;
4141
4142 }
4143                 }
4144             case 'p':
4145               if (strncmp (KR_keyword, "/dev/sdp6", 9) == 0)
4146                 {
4147 {
4148 return dev_storage + 445;
4149
4150 }
4151                 }
4152               else
4153                 {
4154 {
4155 return  NULL;
4156
4157 }
4158                 }
4159             case 'o':
4160               if (strncmp (KR_keyword, "/dev/sdo6", 9) == 0)
4161                 {
4162 {
4163 return dev_storage + 430;
4164
4165 }
4166                 }
4167               else
4168                 {
4169 {
4170 return  NULL;
4171
4172 }
4173                 }
4174             case 'n':
4175               if (strncmp (KR_keyword, "/dev/sdn6", 9) == 0)
4176                 {
4177 {
4178 return dev_storage + 415;
4179
4180 }
4181                 }
4182               else
4183                 {
4184 {
4185 return  NULL;
4186
4187 }
4188                 }
4189             case 'm':
4190               switch (KR_keyword [5])
4191                 {
4192                 case 's':
4193                   if (strncmp (KR_keyword, "/dev/sdm6", 9) == 0)
4194                     {
4195 {
4196 return dev_storage + 400;
4197
4198 }
4199                     }
4200                   else
4201                     {
4202 {
4203 return  NULL;
4204
4205 }
4206                     }
4207                 case 'c':
4208                   if (strncmp (KR_keyword, "/dev/com6", 9) == 0)
4209                     {
4210 {
4211 return dev_storage + 6;
4212
4213 }
4214                     }
4215                   else
4216                     {
4217 {
4218 return  NULL;
4219
4220 }
4221                     }
4222                 default:
4223 {
4224 return  NULL;
4225
4226 }
4227                 }
4228             case 'l':
4229               if (strncmp (KR_keyword, "/dev/sdl6", 9) == 0)
4230                 {
4231 {
4232 return dev_storage + 385;
4233
4234 }
4235                 }
4236               else
4237                 {
4238 {
4239 return  NULL;
4240
4241 }
4242                 }
4243             case 'k':
4244               if (strncmp (KR_keyword, "/dev/sdk6", 9) == 0)
4245                 {
4246 {
4247 return dev_storage + 370;
4248
4249 }
4250                 }
4251               else
4252                 {
4253 {
4254 return  NULL;
4255
4256 }
4257                 }
4258             case 'j':
4259               if (strncmp (KR_keyword, "/dev/sdj6", 9) == 0)
4260                 {
4261 {
4262 return dev_storage + 355;
4263
4264 }
4265                 }
4266               else
4267                 {
4268 {
4269 return  NULL;
4270
4271 }
4272                 }
4273             case 'i':
4274               if (strncmp (KR_keyword, "/dev/sdi6", 9) == 0)
4275                 {
4276 {
4277 return dev_storage + 340;
4278
4279 }
4280                 }
4281               else
4282                 {
4283 {
4284 return  NULL;
4285
4286 }
4287                 }
4288             case 'h':
4289               if (strncmp (KR_keyword, "/dev/sdh6", 9) == 0)
4290                 {
4291 {
4292 return dev_storage + 325;
4293
4294 }
4295                 }
4296               else
4297                 {
4298 {
4299 return  NULL;
4300
4301 }
4302                 }
4303             case 'g':
4304               if (strncmp (KR_keyword, "/dev/sdg6", 9) == 0)
4305                 {
4306 {
4307 return dev_storage + 310;
4308
4309 }
4310                 }
4311               else
4312                 {
4313 {
4314 return  NULL;
4315
4316 }
4317                 }
4318             case 'f':
4319               if (strncmp (KR_keyword, "/dev/sdf6", 9) == 0)
4320                 {
4321 {
4322 return dev_storage + 295;
4323
4324 }
4325                 }
4326               else
4327                 {
4328 {
4329 return  NULL;
4330
4331 }
4332                 }
4333             case 'e':
4334               if (strncmp (KR_keyword, "/dev/sde6", 9) == 0)
4335                 {
4336 {
4337 return dev_storage + 280;
4338
4339 }
4340                 }
4341               else
4342                 {
4343 {
4344 return  NULL;
4345
4346 }
4347                 }
4348             case 'd':
4349               switch (KR_keyword [6])
4350                 {
4351                 case 'd':
4352                   if (strncmp (KR_keyword, "/dev/sdd6", 9) == 0)
4353                     {
4354 {
4355 return dev_storage + 265;
4356
4357 }
4358                     }
4359                   else
4360                     {
4361 {
4362 return  NULL;
4363
4364 }
4365                     }
4366                 case 'c':
4367                   if (strncmp (KR_keyword, "/dev/scd6", 9) == 0)
4368                     {
4369 {
4370 return dev_storage + 179;
4371
4372 }
4373                     }
4374                   else
4375                     {
4376 {
4377 return  NULL;
4378
4379 }
4380                     }
4381                 default:
4382 {
4383 return  NULL;
4384
4385 }
4386                 }
4387             case 'c':
4388               if (strncmp (KR_keyword, "/dev/sdc6", 9) == 0)
4389                 {
4390 {
4391 return dev_storage + 250;
4392
4393 }
4394                 }
4395               else
4396                 {
4397 {
4398 return  NULL;
4399
4400 }
4401                 }
4402             case 'b':
4403               if (strncmp (KR_keyword, "/dev/sdb6", 9) == 0)
4404                 {
4405 {
4406 return dev_storage + 235;
4407
4408 }
4409                 }
4410               else
4411                 {
4412 {
4413 return  NULL;
4414
4415 }
4416                 }
4417             case 'a':
4418               if (strncmp (KR_keyword, "/dev/sda6", 9) == 0)
4419                 {
4420 {
4421 return dev_storage + 220;
4422
4423 }
4424                 }
4425               else
4426                 {
4427 {
4428 return  NULL;
4429
4430 }
4431                 }
4432             case '9':
4433               if (strncmp (KR_keyword, "/dev/st96", 9) == 0)
4434                 {
4435 {
4436 return dev_storage + 717;
4437
4438 }
4439                 }
4440               else
4441                 {
4442 {
4443 return  NULL;
4444
4445 }
4446                 }
4447             case '8':
4448               if (strncmp (KR_keyword, "/dev/st86", 9) == 0)
4449                 {
4450 {
4451 return dev_storage + 707;
4452
4453 }
4454                 }
4455               else
4456                 {
4457 {
4458 return  NULL;
4459
4460 }
4461                 }
4462             case '7':
4463               if (strncmp (KR_keyword, "/dev/st76", 9) == 0)
4464                 {
4465 {
4466 return dev_storage + 697;
4467
4468 }
4469                 }
4470               else
4471                 {
4472 {
4473 return  NULL;
4474
4475 }
4476                 }
4477             case '6':
4478               if (strncmp (KR_keyword, "/dev/st66", 9) == 0)
4479                 {
4480 {
4481 return dev_storage + 687;
4482
4483 }
4484                 }
4485               else
4486                 {
4487 {
4488 return  NULL;
4489
4490 }
4491                 }
4492             case '5':
4493               if (strncmp (KR_keyword, "/dev/st56", 9) == 0)
4494                 {
4495 {
4496 return dev_storage + 677;
4497
4498 }
4499                 }
4500               else
4501                 {
4502 {
4503 return  NULL;
4504
4505 }
4506                 }
4507             case '4':
4508               if (strncmp (KR_keyword, "/dev/st46", 9) == 0)
4509                 {
4510 {
4511 return dev_storage + 667;
4512
4513 }
4514                 }
4515               else
4516                 {
4517 {
4518 return  NULL;
4519
4520 }
4521                 }
4522             case '3':
4523               if (strncmp (KR_keyword, "/dev/st36", 9) == 0)
4524                 {
4525 {
4526 return dev_storage + 657;
4527
4528 }
4529                 }
4530               else
4531                 {
4532 {
4533 return  NULL;
4534
4535 }
4536                 }
4537             case '2':
4538               if (strncmp (KR_keyword, "/dev/st26", 9) == 0)
4539                 {
4540 {
4541 return dev_storage + 647;
4542
4543 }
4544                 }
4545               else
4546                 {
4547 {
4548 return  NULL;
4549
4550 }
4551                 }
4552             case '1':
4553               if (strncmp (KR_keyword, "/dev/st16", 9) == 0)
4554                 {
4555 {
4556 return dev_storage + 637;
4557
4558 }
4559                 }
4560               else
4561                 {
4562 {
4563 return  NULL;
4564
4565 }
4566                 }
4567             default:
4568 {
4569 return  NULL;
4570
4571 }
4572             }
4573         case '5':
4574           switch (KR_keyword [7])
4575             {
4576             case 'z':
4577               if (strncmp (KR_keyword, "/dev/sdz5", 9) == 0)
4578                 {
4579 {
4580 return dev_storage + 594;
4581
4582 }
4583                 }
4584               else
4585                 {
4586 {
4587 return  NULL;
4588
4589 }
4590                 }
4591             case 'y':
4592               switch (KR_keyword [5])
4593                 {
4594                 case 't':
4595                   if (strncmp (KR_keyword, "/dev/tty5", 9) == 0)
4596                     {
4597 {
4598 return dev_storage + 755;
4599
4600 }
4601                     }
4602                   else
4603                     {
4604 {
4605 return  NULL;
4606
4607 }
4608                     }
4609                 case 's':
4610                   if (strncmp (KR_keyword, "/dev/sdy5", 9) == 0)
4611                     {
4612 {
4613 return dev_storage + 579;
4614
4615 }
4616                     }
4617                   else
4618                     {
4619 {
4620 return  NULL;
4621
4622 }
4623                     }
4624                 default:
4625 {
4626 return  NULL;
4627
4628 }
4629                 }
4630             case 'x':
4631               if (strncmp (KR_keyword, "/dev/sdx5", 9) == 0)
4632                 {
4633 {
4634 return dev_storage + 564;
4635
4636 }
4637                 }
4638               else
4639                 {
4640 {
4641 return  NULL;
4642
4643 }
4644                 }
4645             case 'w':
4646               if (strncmp (KR_keyword, "/dev/sdw5", 9) == 0)
4647                 {
4648 {
4649 return dev_storage + 549;
4650
4651 }
4652                 }
4653               else
4654                 {
4655 {
4656 return  NULL;
4657
4658 }
4659                 }
4660             case 'v':
4661               if (strncmp (KR_keyword, "/dev/sdv5", 9) == 0)
4662                 {
4663 {
4664 return dev_storage + 534;
4665
4666 }
4667                 }
4668               else
4669                 {
4670 {
4671 return  NULL;
4672
4673 }
4674                 }
4675             case 'u':
4676               if (strncmp (KR_keyword, "/dev/sdu5", 9) == 0)
4677                 {
4678 {
4679 return dev_storage + 519;
4680
4681 }
4682                 }
4683               else
4684                 {
4685 {
4686 return  NULL;
4687
4688 }
4689                 }
4690             case 't':
4691               switch (KR_keyword [5])
4692                 {
4693                 case 's':
4694                   if (strncmp (KR_keyword, "/dev/sdt5", 9) == 0)
4695                     {
4696 {
4697 return dev_storage + 504;
4698
4699 }
4700                     }
4701                   else
4702                     {
4703 {
4704 return  NULL;
4705
4706 }
4707                     }
4708                 case 'n':
4709                   if (strncmp (KR_keyword, "/dev/nst5", 9) == 0)
4710                     {
4711 {
4712 return dev_storage + 45;
4713
4714 }
4715                     }
4716                   else
4717                     {
4718 {
4719 return  NULL;
4720
4721 }
4722                     }
4723                 default:
4724 {
4725 return  NULL;
4726
4727 }
4728                 }
4729             case 's':
4730               if (strncmp (KR_keyword, "/dev/sds5", 9) == 0)
4731                 {
4732 {
4733 return dev_storage + 489;
4734
4735 }
4736                 }
4737               else
4738                 {
4739 {
4740 return  NULL;
4741
4742 }
4743                 }
4744             case 'r':
4745               if (strncmp (KR_keyword, "/dev/sdr5", 9) == 0)
4746                 {
4747 {
4748 return dev_storage + 474;
4749
4750 }
4751                 }
4752               else
4753                 {
4754 {
4755 return  NULL;
4756
4757 }
4758                 }
4759             case 'q':
4760               if (strncmp (KR_keyword, "/dev/sdq5", 9) == 0)
4761                 {
4762 {
4763 return dev_storage + 459;
4764
4765 }
4766                 }
4767               else
4768                 {
4769 {
4770 return  NULL;
4771
4772 }
4773                 }
4774             case 'p':
4775               if (strncmp (KR_keyword, "/dev/sdp5", 9) == 0)
4776                 {
4777 {
4778 return dev_storage + 444;
4779
4780 }
4781                 }
4782               else
4783                 {
4784 {
4785 return  NULL;
4786
4787 }
4788                 }
4789             case 'o':
4790               if (strncmp (KR_keyword, "/dev/sdo5", 9) == 0)
4791                 {
4792 {
4793 return dev_storage + 429;
4794
4795 }
4796                 }
4797               else
4798                 {
4799 {
4800 return  NULL;
4801
4802 }
4803                 }
4804             case 'n':
4805               if (strncmp (KR_keyword, "/dev/sdn5", 9) == 0)
4806                 {
4807 {
4808 return dev_storage + 414;
4809
4810 }
4811                 }
4812               else
4813                 {
4814 {
4815 return  NULL;
4816
4817 }
4818                 }
4819             case 'm':
4820               switch (KR_keyword [5])
4821                 {
4822                 case 's':
4823                   if (strncmp (KR_keyword, "/dev/sdm5", 9) == 0)
4824                     {
4825 {
4826 return dev_storage + 399;
4827
4828 }
4829                     }
4830                   else
4831                     {
4832 {
4833 return  NULL;
4834
4835 }
4836                     }
4837                 case 'c':
4838                   if (strncmp (KR_keyword, "/dev/com5", 9) == 0)
4839                     {
4840 {
4841 return dev_storage + 5;
4842
4843 }
4844                     }
4845                   else
4846                     {
4847 {
4848 return  NULL;
4849
4850 }
4851                     }
4852                 default:
4853 {
4854 return  NULL;
4855
4856 }
4857                 }
4858             case 'l':
4859               if (strncmp (KR_keyword, "/dev/sdl5", 9) == 0)
4860                 {
4861 {
4862 return dev_storage + 384;
4863
4864 }
4865                 }
4866               else
4867                 {
4868 {
4869 return  NULL;
4870
4871 }
4872                 }
4873             case 'k':
4874               if (strncmp (KR_keyword, "/dev/sdk5", 9) == 0)
4875                 {
4876 {
4877 return dev_storage + 369;
4878
4879 }
4880                 }
4881               else
4882                 {
4883 {
4884 return  NULL;
4885
4886 }
4887                 }
4888             case 'j':
4889               if (strncmp (KR_keyword, "/dev/sdj5", 9) == 0)
4890                 {
4891 {
4892 return dev_storage + 354;
4893
4894 }
4895                 }
4896               else
4897                 {
4898 {
4899 return  NULL;
4900
4901 }
4902                 }
4903             case 'i':
4904               if (strncmp (KR_keyword, "/dev/sdi5", 9) == 0)
4905                 {
4906 {
4907 return dev_storage + 339;
4908
4909 }
4910                 }
4911               else
4912                 {
4913 {
4914 return  NULL;
4915
4916 }
4917                 }
4918             case 'h':
4919               if (strncmp (KR_keyword, "/dev/sdh5", 9) == 0)
4920                 {
4921 {
4922 return dev_storage + 324;
4923
4924 }
4925                 }
4926               else
4927                 {
4928 {
4929 return  NULL;
4930
4931 }
4932                 }
4933             case 'g':
4934               if (strncmp (KR_keyword, "/dev/sdg5", 9) == 0)
4935                 {
4936 {
4937 return dev_storage + 309;
4938
4939 }
4940                 }
4941               else
4942                 {
4943 {
4944 return  NULL;
4945
4946 }
4947                 }
4948             case 'f':
4949               if (strncmp (KR_keyword, "/dev/sdf5", 9) == 0)
4950                 {
4951 {
4952 return dev_storage + 294;
4953
4954 }
4955                 }
4956               else
4957                 {
4958 {
4959 return  NULL;
4960
4961 }
4962                 }
4963             case 'e':
4964               if (strncmp (KR_keyword, "/dev/sde5", 9) == 0)
4965                 {
4966 {
4967 return dev_storage + 279;
4968
4969 }
4970                 }
4971               else
4972                 {
4973 {
4974 return  NULL;
4975
4976 }
4977                 }
4978             case 'd':
4979               switch (KR_keyword [6])
4980                 {
4981                 case 'd':
4982                   if (strncmp (KR_keyword, "/dev/sdd5", 9) == 0)
4983                     {
4984 {
4985 return dev_storage + 264;
4986
4987 }
4988                     }
4989                   else
4990                     {
4991 {
4992 return  NULL;
4993
4994 }
4995                     }
4996                 case 'c':
4997                   if (strncmp (KR_keyword, "/dev/scd5", 9) == 0)
4998                     {
4999 {
5000 return dev_storage + 178;
5001
5002 }
5003                     }
5004                   else
5005                     {
5006 {
5007 return  NULL;
5008
5009 }
5010                     }
5011                 default:
5012 {
5013 return  NULL;
5014
5015 }
5016                 }
5017             case 'c':
5018               if (strncmp (KR_keyword, "/dev/sdc5", 9) == 0)
5019                 {
5020 {
5021 return dev_storage + 249;
5022
5023 }
5024                 }
5025               else
5026                 {
5027 {
5028 return  NULL;
5029
5030 }
5031                 }
5032             case 'b':
5033               if (strncmp (KR_keyword, "/dev/sdb5", 9) == 0)
5034                 {
5035 {
5036 return dev_storage + 234;
5037
5038 }
5039                 }
5040               else
5041                 {
5042 {
5043 return  NULL;
5044
5045 }
5046                 }
5047             case 'a':
5048               if (strncmp (KR_keyword, "/dev/sda5", 9) == 0)
5049                 {
5050 {
5051 return dev_storage + 219;
5052
5053 }
5054                 }
5055               else
5056                 {
5057 {
5058 return  NULL;
5059
5060 }
5061                 }
5062             case '9':
5063               if (strncmp (KR_keyword, "/dev/st95", 9) == 0)
5064                 {
5065 {
5066 return dev_storage + 716;
5067
5068 }
5069                 }
5070               else
5071                 {
5072 {
5073 return  NULL;
5074
5075 }
5076                 }
5077             case '8':
5078               if (strncmp (KR_keyword, "/dev/st85", 9) == 0)
5079                 {
5080 {
5081 return dev_storage + 706;
5082
5083 }
5084                 }
5085               else
5086                 {
5087 {
5088 return  NULL;
5089
5090 }
5091                 }
5092             case '7':
5093               if (strncmp (KR_keyword, "/dev/st75", 9) == 0)
5094                 {
5095 {
5096 return dev_storage + 696;
5097
5098 }
5099                 }
5100               else
5101                 {
5102 {
5103 return  NULL;
5104
5105 }
5106                 }
5107             case '6':
5108               if (strncmp (KR_keyword, "/dev/st65", 9) == 0)
5109                 {
5110 {
5111 return dev_storage + 686;
5112
5113 }
5114                 }
5115               else
5116                 {
5117 {
5118 return  NULL;
5119
5120 }
5121                 }
5122             case '5':
5123               if (strncmp (KR_keyword, "/dev/st55", 9) == 0)
5124                 {
5125 {
5126 return dev_storage + 676;
5127
5128 }
5129                 }
5130               else
5131                 {
5132 {
5133 return  NULL;
5134
5135 }
5136                 }
5137             case '4':
5138               if (strncmp (KR_keyword, "/dev/st45", 9) == 0)
5139                 {
5140 {
5141 return dev_storage + 666;
5142
5143 }
5144                 }
5145               else
5146                 {
5147 {
5148 return  NULL;
5149
5150 }
5151                 }
5152             case '3':
5153               if (strncmp (KR_keyword, "/dev/st35", 9) == 0)
5154                 {
5155 {
5156 return dev_storage + 656;
5157
5158 }
5159                 }
5160               else
5161                 {
5162 {
5163 return  NULL;
5164
5165 }
5166                 }
5167             case '2':
5168               if (strncmp (KR_keyword, "/dev/st25", 9) == 0)
5169                 {
5170 {
5171 return dev_storage + 646;
5172
5173 }
5174                 }
5175               else
5176                 {
5177 {
5178 return  NULL;
5179
5180 }
5181                 }
5182             case '1':
5183               switch (KR_keyword [6])
5184                 {
5185                 case 't':
5186                   if (strncmp (KR_keyword, "/dev/st15", 9) == 0)
5187                     {
5188 {
5189 return dev_storage + 636;
5190
5191 }
5192                     }
5193                   else
5194                     {
5195 {
5196 return  NULL;
5197
5198 }
5199                     }
5200                 case 'r':
5201                   if (strncmp (KR_keyword, "/dev/sr15", 9) == 0)
5202                     {
5203 {
5204 return dev_storage + 620;
5205
5206 }
5207                     }
5208                   else
5209                     {
5210 {
5211 return  NULL;
5212
5213 }
5214                     }
5215                 case 'd':
5216                   if (strncmp (KR_keyword, "/dev/fd15", 9) == 0)
5217                     {
5218 {
5219 return dev_storage + 36;
5220
5221 }
5222                     }
5223                   else
5224                     {
5225 {
5226 return  NULL;
5227
5228 }
5229                     }
5230                 default:
5231 {
5232 return  NULL;
5233
5234 }
5235                 }
5236             default:
5237 {
5238 return  NULL;
5239
5240 }
5241             }
5242         case '4':
5243           switch (KR_keyword [7])
5244             {
5245             case 'z':
5246               if (strncmp (KR_keyword, "/dev/sdz4", 9) == 0)
5247                 {
5248 {
5249 return dev_storage + 593;
5250
5251 }
5252                 }
5253               else
5254                 {
5255 {
5256 return  NULL;
5257
5258 }
5259                 }
5260             case 'y':
5261               switch (KR_keyword [5])
5262                 {
5263                 case 't':
5264                   if (strncmp (KR_keyword, "/dev/tty4", 9) == 0)
5265                     {
5266 {
5267 return dev_storage + 754;
5268
5269 }
5270                     }
5271                   else
5272                     {
5273 {
5274 return  NULL;
5275
5276 }
5277                     }
5278                 case 's':
5279                   if (strncmp (KR_keyword, "/dev/sdy4", 9) == 0)
5280                     {
5281 {
5282 return dev_storage + 578;
5283
5284 }
5285                     }
5286                   else
5287                     {
5288 {
5289 return  NULL;
5290
5291 }
5292                     }
5293                 default:
5294 {
5295 return  NULL;
5296
5297 }
5298                 }
5299             case 'x':
5300               if (strncmp (KR_keyword, "/dev/sdx4", 9) == 0)
5301                 {
5302 {
5303 return dev_storage + 563;
5304
5305 }
5306                 }
5307               else
5308                 {
5309 {
5310 return  NULL;
5311
5312 }
5313                 }
5314             case 'w':
5315               if (strncmp (KR_keyword, "/dev/sdw4", 9) == 0)
5316                 {
5317 {
5318 return dev_storage + 548;
5319
5320 }
5321                 }
5322               else
5323                 {
5324 {
5325 return  NULL;
5326
5327 }
5328                 }
5329             case 'v':
5330               if (strncmp (KR_keyword, "/dev/sdv4", 9) == 0)
5331                 {
5332 {
5333 return dev_storage + 533;
5334
5335 }
5336                 }
5337               else
5338                 {
5339 {
5340 return  NULL;
5341
5342 }
5343                 }
5344             case 'u':
5345               if (strncmp (KR_keyword, "/dev/sdu4", 9) == 0)
5346                 {
5347 {
5348 return dev_storage + 518;
5349
5350 }
5351                 }
5352               else
5353                 {
5354 {
5355 return  NULL;
5356
5357 }
5358                 }
5359             case 't':
5360               switch (KR_keyword [5])
5361                 {
5362                 case 's':
5363                   if (strncmp (KR_keyword, "/dev/sdt4", 9) == 0)
5364                     {
5365 {
5366 return dev_storage + 503;
5367
5368 }
5369                     }
5370                   else
5371                     {
5372 {
5373 return  NULL;
5374
5375 }
5376                     }
5377                 case 'n':
5378                   if (strncmp (KR_keyword, "/dev/nst4", 9) == 0)
5379                     {
5380 {
5381 return dev_storage + 44;
5382
5383 }
5384                     }
5385                   else
5386                     {
5387 {
5388 return  NULL;
5389
5390 }
5391                     }
5392                 default:
5393 {
5394 return  NULL;
5395
5396 }
5397                 }
5398             case 's':
5399               if (strncmp (KR_keyword, "/dev/sds4", 9) == 0)
5400                 {
5401 {
5402 return dev_storage + 488;
5403
5404 }
5405                 }
5406               else
5407                 {
5408 {
5409 return  NULL;
5410
5411 }
5412                 }
5413             case 'r':
5414               if (strncmp (KR_keyword, "/dev/sdr4", 9) == 0)
5415                 {
5416 {
5417 return dev_storage + 473;
5418
5419 }
5420                 }
5421               else
5422                 {
5423 {
5424 return  NULL;
5425
5426 }
5427                 }
5428             case 'q':
5429               if (strncmp (KR_keyword, "/dev/sdq4", 9) == 0)
5430                 {
5431 {
5432 return dev_storage + 458;
5433
5434 }
5435                 }
5436               else
5437                 {
5438 {
5439 return  NULL;
5440
5441 }
5442                 }
5443             case 'p':
5444               if (strncmp (KR_keyword, "/dev/sdp4", 9) == 0)
5445                 {
5446 {
5447 return dev_storage + 443;
5448
5449 }
5450                 }
5451               else
5452                 {
5453 {
5454 return  NULL;
5455
5456 }
5457                 }
5458             case 'o':
5459               if (strncmp (KR_keyword, "/dev/sdo4", 9) == 0)
5460                 {
5461 {
5462 return dev_storage + 428;
5463
5464 }
5465                 }
5466               else
5467                 {
5468 {
5469 return  NULL;
5470
5471 }
5472                 }
5473             case 'n':
5474               if (strncmp (KR_keyword, "/dev/sdn4", 9) == 0)
5475                 {
5476 {
5477 return dev_storage + 413;
5478
5479 }
5480                 }
5481               else
5482                 {
5483 {
5484 return  NULL;
5485
5486 }
5487                 }
5488             case 'm':
5489               switch (KR_keyword [5])
5490                 {
5491                 case 's':
5492                   if (strncmp (KR_keyword, "/dev/sdm4", 9) == 0)
5493                     {
5494 {
5495 return dev_storage + 398;
5496
5497 }
5498                     }
5499                   else
5500                     {
5501 {
5502 return  NULL;
5503
5504 }
5505                     }
5506                 case 'c':
5507                   if (strncmp (KR_keyword, "/dev/com4", 9) == 0)
5508                     {
5509 {
5510 return dev_storage + 4;
5511
5512 }
5513                     }
5514                   else
5515                     {
5516 {
5517 return  NULL;
5518
5519 }
5520                     }
5521                 default:
5522 {
5523 return  NULL;
5524
5525 }
5526                 }
5527             case 'l':
5528               if (strncmp (KR_keyword, "/dev/sdl4", 9) == 0)
5529                 {
5530 {
5531 return dev_storage + 383;
5532
5533 }
5534                 }
5535               else
5536                 {
5537 {
5538 return  NULL;
5539
5540 }
5541                 }
5542             case 'k':
5543               if (strncmp (KR_keyword, "/dev/sdk4", 9) == 0)
5544                 {
5545 {
5546 return dev_storage + 368;
5547
5548 }
5549                 }
5550               else
5551                 {
5552 {
5553 return  NULL;
5554
5555 }
5556                 }
5557             case 'j':
5558               if (strncmp (KR_keyword, "/dev/sdj4", 9) == 0)
5559                 {
5560 {
5561 return dev_storage + 353;
5562
5563 }
5564                 }
5565               else
5566                 {
5567 {
5568 return  NULL;
5569
5570 }
5571                 }
5572             case 'i':
5573               if (strncmp (KR_keyword, "/dev/sdi4", 9) == 0)
5574                 {
5575 {
5576 return dev_storage + 338;
5577
5578 }
5579                 }
5580               else
5581                 {
5582 {
5583 return  NULL;
5584
5585 }
5586                 }
5587             case 'h':
5588               if (strncmp (KR_keyword, "/dev/sdh4", 9) == 0)
5589                 {
5590 {
5591 return dev_storage + 323;
5592
5593 }
5594                 }
5595               else
5596                 {
5597 {
5598 return  NULL;
5599
5600 }
5601                 }
5602             case 'g':
5603               if (strncmp (KR_keyword, "/dev/sdg4", 9) == 0)
5604                 {
5605 {
5606 return dev_storage + 308;
5607
5608 }
5609                 }
5610               else
5611                 {
5612 {
5613 return  NULL;
5614
5615 }
5616                 }
5617             case 'f':
5618               if (strncmp (KR_keyword, "/dev/sdf4", 9) == 0)
5619                 {
5620 {
5621 return dev_storage + 293;
5622
5623 }
5624                 }
5625               else
5626                 {
5627 {
5628 return  NULL;
5629
5630 }
5631                 }
5632             case 'e':
5633               if (strncmp (KR_keyword, "/dev/sde4", 9) == 0)
5634                 {
5635 {
5636 return dev_storage + 278;
5637
5638 }
5639                 }
5640               else
5641                 {
5642 {
5643 return  NULL;
5644
5645 }
5646                 }
5647             case 'd':
5648               switch (KR_keyword [6])
5649                 {
5650                 case 'd':
5651                   if (strncmp (KR_keyword, "/dev/sdd4", 9) == 0)
5652                     {
5653 {
5654 return dev_storage + 263;
5655
5656 }
5657                     }
5658                   else
5659                     {
5660 {
5661 return  NULL;
5662
5663 }
5664                     }
5665                 case 'c':
5666                   if (strncmp (KR_keyword, "/dev/scd4", 9) == 0)
5667                     {
5668 {
5669 return dev_storage + 177;
5670
5671 }
5672                     }
5673                   else
5674                     {
5675 {
5676 return  NULL;
5677
5678 }
5679                     }
5680                 default:
5681 {
5682 return  NULL;
5683
5684 }
5685                 }
5686             case 'c':
5687               if (strncmp (KR_keyword, "/dev/sdc4", 9) == 0)
5688                 {
5689 {
5690 return dev_storage + 248;
5691
5692 }
5693                 }
5694               else
5695                 {
5696 {
5697 return  NULL;
5698
5699 }
5700                 }
5701             case 'b':
5702               if (strncmp (KR_keyword, "/dev/sdb4", 9) == 0)
5703                 {
5704 {
5705 return dev_storage + 233;
5706
5707 }
5708                 }
5709               else
5710                 {
5711 {
5712 return  NULL;
5713
5714 }
5715                 }
5716             case 'a':
5717               if (strncmp (KR_keyword, "/dev/sda4", 9) == 0)
5718                 {
5719 {
5720 return dev_storage + 218;
5721
5722 }
5723                 }
5724               else
5725                 {
5726 {
5727 return  NULL;
5728
5729 }
5730                 }
5731             case '9':
5732               if (strncmp (KR_keyword, "/dev/st94", 9) == 0)
5733                 {
5734 {
5735 return dev_storage + 715;
5736
5737 }
5738                 }
5739               else
5740                 {
5741 {
5742 return  NULL;
5743
5744 }
5745                 }
5746             case '8':
5747               if (strncmp (KR_keyword, "/dev/st84", 9) == 0)
5748                 {
5749 {
5750 return dev_storage + 705;
5751
5752 }
5753                 }
5754               else
5755                 {
5756 {
5757 return  NULL;
5758
5759 }
5760                 }
5761             case '7':
5762               if (strncmp (KR_keyword, "/dev/st74", 9) == 0)
5763                 {
5764 {
5765 return dev_storage + 695;
5766
5767 }
5768                 }
5769               else
5770                 {
5771 {
5772 return  NULL;
5773
5774 }
5775                 }
5776             case '6':
5777               if (strncmp (KR_keyword, "/dev/st64", 9) == 0)
5778                 {
5779 {
5780 return dev_storage + 685;
5781
5782 }
5783                 }
5784               else
5785                 {
5786 {
5787 return  NULL;
5788
5789 }
5790                 }
5791             case '5':
5792               if (strncmp (KR_keyword, "/dev/st54", 9) == 0)
5793                 {
5794 {
5795 return dev_storage + 675;
5796
5797 }
5798                 }
5799               else
5800                 {
5801 {
5802 return  NULL;
5803
5804 }
5805                 }
5806             case '4':
5807               if (strncmp (KR_keyword, "/dev/st44", 9) == 0)
5808                 {
5809 {
5810 return dev_storage + 665;
5811
5812 }
5813                 }
5814               else
5815                 {
5816 {
5817 return  NULL;
5818
5819 }
5820                 }
5821             case '3':
5822               if (strncmp (KR_keyword, "/dev/st34", 9) == 0)
5823                 {
5824 {
5825 return dev_storage + 655;
5826
5827 }
5828                 }
5829               else
5830                 {
5831 {
5832 return  NULL;
5833
5834 }
5835                 }
5836             case '2':
5837               if (strncmp (KR_keyword, "/dev/st24", 9) == 0)
5838                 {
5839 {
5840 return dev_storage + 645;
5841
5842 }
5843                 }
5844               else
5845                 {
5846 {
5847 return  NULL;
5848
5849 }
5850                 }
5851             case '1':
5852               switch (KR_keyword [6])
5853                 {
5854                 case 't':
5855                   if (strncmp (KR_keyword, "/dev/st14", 9) == 0)
5856                     {
5857 {
5858 return dev_storage + 635;
5859
5860 }
5861                     }
5862                   else
5863                     {
5864 {
5865 return  NULL;
5866
5867 }
5868                     }
5869                 case 'r':
5870                   if (strncmp (KR_keyword, "/dev/sr14", 9) == 0)
5871                     {
5872 {
5873 return dev_storage + 619;
5874
5875 }
5876                     }
5877                   else
5878                     {
5879 {
5880 return  NULL;
5881
5882 }
5883                     }
5884                 case 'd':
5885                   if (strncmp (KR_keyword, "/dev/fd14", 9) == 0)
5886                     {
5887 {
5888 return dev_storage + 35;
5889
5890 }
5891                     }
5892                   else
5893                     {
5894 {
5895 return  NULL;
5896
5897 }
5898                     }
5899                 default:
5900 {
5901 return  NULL;
5902
5903 }
5904                 }
5905             default:
5906 {
5907 return  NULL;
5908
5909 }
5910             }
5911         case '3':
5912           switch (KR_keyword [7])
5913             {
5914             case 'z':
5915               if (strncmp (KR_keyword, "/dev/sdz3", 9) == 0)
5916                 {
5917 {
5918 return dev_storage + 592;
5919
5920 }
5921                 }
5922               else
5923                 {
5924 {
5925 return  NULL;
5926
5927 }
5928                 }
5929             case 'y':
5930               switch (KR_keyword [5])
5931                 {
5932                 case 't':
5933                   if (strncmp (KR_keyword, "/dev/tty3", 9) == 0)
5934                     {
5935 {
5936 return dev_storage + 753;
5937
5938 }
5939                     }
5940                   else
5941                     {
5942 {
5943 return  NULL;
5944
5945 }
5946                     }
5947                 case 's':
5948                   if (strncmp (KR_keyword, "/dev/sdy3", 9) == 0)
5949                     {
5950 {
5951 return dev_storage + 577;
5952
5953 }
5954                     }
5955                   else
5956                     {
5957 {
5958 return  NULL;
5959
5960 }
5961                     }
5962                 default:
5963 {
5964 return  NULL;
5965
5966 }
5967                 }
5968             case 'x':
5969               if (strncmp (KR_keyword, "/dev/sdx3", 9) == 0)
5970                 {
5971 {
5972 return dev_storage + 562;
5973
5974 }
5975                 }
5976               else
5977                 {
5978 {
5979 return  NULL;
5980
5981 }
5982                 }
5983             case 'w':
5984               if (strncmp (KR_keyword, "/dev/sdw3", 9) == 0)
5985                 {
5986 {
5987 return dev_storage + 547;
5988
5989 }
5990                 }
5991               else
5992                 {
5993 {
5994 return  NULL;
5995
5996 }
5997                 }
5998             case 'v':
5999               if (strncmp (KR_keyword, "/dev/sdv3", 9) == 0)
6000                 {
6001 {
6002 return dev_storage + 532;
6003
6004 }
6005                 }
6006               else
6007                 {
6008 {
6009 return  NULL;
6010
6011 }
6012                 }
6013             case 'u':
6014               if (strncmp (KR_keyword, "/dev/sdu3", 9) == 0)
6015                 {
6016 {
6017 return dev_storage + 517;
6018
6019 }
6020                 }
6021               else
6022                 {
6023 {
6024 return  NULL;
6025
6026 }
6027                 }
6028             case 't':
6029               switch (KR_keyword [5])
6030                 {
6031                 case 's':
6032                   if (strncmp (KR_keyword, "/dev/sdt3", 9) == 0)
6033                     {
6034 {
6035 return dev_storage + 502;
6036
6037 }
6038                     }
6039                   else
6040                     {
6041 {
6042 return  NULL;
6043
6044 }
6045                     }
6046                 case 'n':
6047                   if (strncmp (KR_keyword, "/dev/nst3", 9) == 0)
6048                     {
6049 {
6050 return dev_storage + 43;
6051
6052 }
6053                     }
6054                   else
6055                     {
6056 {
6057 return  NULL;
6058
6059 }
6060                     }
6061                 default:
6062 {
6063 return  NULL;
6064
6065 }
6066                 }
6067             case 's':
6068               if (strncmp (KR_keyword, "/dev/sds3", 9) == 0)
6069                 {
6070 {
6071 return dev_storage + 487;
6072
6073 }
6074                 }
6075               else
6076                 {
6077 {
6078 return  NULL;
6079
6080 }
6081                 }
6082             case 'r':
6083               if (strncmp (KR_keyword, "/dev/sdr3", 9) == 0)
6084                 {
6085 {
6086 return dev_storage + 472;
6087
6088 }
6089                 }
6090               else
6091                 {
6092 {
6093 return  NULL;
6094
6095 }
6096                 }
6097             case 'q':
6098               if (strncmp (KR_keyword, "/dev/sdq3", 9) == 0)
6099                 {
6100 {
6101 return dev_storage + 457;
6102
6103 }
6104                 }
6105               else
6106                 {
6107 {
6108 return  NULL;
6109
6110 }
6111                 }
6112             case 'p':
6113               if (strncmp (KR_keyword, "/dev/sdp3", 9) == 0)
6114                 {
6115 {
6116 return dev_storage + 442;
6117
6118 }
6119                 }
6120               else
6121                 {
6122 {
6123 return  NULL;
6124
6125 }
6126                 }
6127             case 'o':
6128               if (strncmp (KR_keyword, "/dev/sdo3", 9) == 0)
6129                 {
6130 {
6131 return dev_storage + 427;
6132
6133 }
6134                 }
6135               else
6136                 {
6137 {
6138 return  NULL;
6139
6140 }
6141                 }
6142             case 'n':
6143               if (strncmp (KR_keyword, "/dev/sdn3", 9) == 0)
6144                 {
6145 {
6146 return dev_storage + 412;
6147
6148 }
6149                 }
6150               else
6151                 {
6152 {
6153 return  NULL;
6154
6155 }
6156                 }
6157             case 'm':
6158               switch (KR_keyword [5])
6159                 {
6160                 case 's':
6161                   if (strncmp (KR_keyword, "/dev/sdm3", 9) == 0)
6162                     {
6163 {
6164 return dev_storage + 397;
6165
6166 }
6167                     }
6168                   else
6169                     {
6170 {
6171 return  NULL;
6172
6173 }
6174                     }
6175                 case 'c':
6176                   if (strncmp (KR_keyword, "/dev/com3", 9) == 0)
6177                     {
6178 {
6179 return dev_storage + 3;
6180
6181 }
6182                     }
6183                   else
6184                     {
6185 {
6186 return  NULL;
6187
6188 }
6189                     }
6190                 default:
6191 {
6192 return  NULL;
6193
6194 }
6195                 }
6196             case 'l':
6197               if (strncmp (KR_keyword, "/dev/sdl3", 9) == 0)
6198                 {
6199 {
6200 return dev_storage + 382;
6201
6202 }
6203                 }
6204               else
6205                 {
6206 {
6207 return  NULL;
6208
6209 }
6210                 }
6211             case 'k':
6212               if (strncmp (KR_keyword, "/dev/sdk3", 9) == 0)
6213                 {
6214 {
6215 return dev_storage + 367;
6216
6217 }
6218                 }
6219               else
6220                 {
6221 {
6222 return  NULL;
6223
6224 }
6225                 }
6226             case 'j':
6227               if (strncmp (KR_keyword, "/dev/sdj3", 9) == 0)
6228                 {
6229 {
6230 return dev_storage + 352;
6231
6232 }
6233                 }
6234               else
6235                 {
6236 {
6237 return  NULL;
6238
6239 }
6240                 }
6241             case 'i':
6242               if (strncmp (KR_keyword, "/dev/sdi3", 9) == 0)
6243                 {
6244 {
6245 return dev_storage + 337;
6246
6247 }
6248                 }
6249               else
6250                 {
6251 {
6252 return  NULL;
6253
6254 }
6255                 }
6256             case 'h':
6257               if (strncmp (KR_keyword, "/dev/sdh3", 9) == 0)
6258                 {
6259 {
6260 return dev_storage + 322;
6261
6262 }
6263                 }
6264               else
6265                 {
6266 {
6267 return  NULL;
6268
6269 }
6270                 }
6271             case 'g':
6272               if (strncmp (KR_keyword, "/dev/sdg3", 9) == 0)
6273                 {
6274 {
6275 return dev_storage + 307;
6276
6277 }
6278                 }
6279               else
6280                 {
6281 {
6282 return  NULL;
6283
6284 }
6285                 }
6286             case 'f':
6287               if (strncmp (KR_keyword, "/dev/sdf3", 9) == 0)
6288                 {
6289 {
6290 return dev_storage + 292;
6291
6292 }
6293                 }
6294               else
6295                 {
6296 {
6297 return  NULL;
6298
6299 }
6300                 }
6301             case 'e':
6302               if (strncmp (KR_keyword, "/dev/sde3", 9) == 0)
6303                 {
6304 {
6305 return dev_storage + 277;
6306
6307 }
6308                 }
6309               else
6310                 {
6311 {
6312 return  NULL;
6313
6314 }
6315                 }
6316             case 'd':
6317               switch (KR_keyword [6])
6318                 {
6319                 case 'd':
6320                   if (strncmp (KR_keyword, "/dev/sdd3", 9) == 0)
6321                     {
6322 {
6323 return dev_storage + 262;
6324
6325 }
6326                     }
6327                   else
6328                     {
6329 {
6330 return  NULL;
6331
6332 }
6333                     }
6334                 case 'c':
6335                   if (strncmp (KR_keyword, "/dev/scd3", 9) == 0)
6336                     {
6337 {
6338 return dev_storage + 176;
6339
6340 }
6341                     }
6342                   else
6343                     {
6344 {
6345 return  NULL;
6346
6347 }
6348                     }
6349                 default:
6350 {
6351 return  NULL;
6352
6353 }
6354                 }
6355             case 'c':
6356               if (strncmp (KR_keyword, "/dev/sdc3", 9) == 0)
6357                 {
6358 {
6359 return dev_storage + 247;
6360
6361 }
6362                 }
6363               else
6364                 {
6365 {
6366 return  NULL;
6367
6368 }
6369                 }
6370             case 'b':
6371               if (strncmp (KR_keyword, "/dev/sdb3", 9) == 0)
6372                 {
6373 {
6374 return dev_storage + 232;
6375
6376 }
6377                 }
6378               else
6379                 {
6380 {
6381 return  NULL;
6382
6383 }
6384                 }
6385             case 'a':
6386               if (strncmp (KR_keyword, "/dev/sda3", 9) == 0)
6387                 {
6388 {
6389 return dev_storage + 217;
6390
6391 }
6392                 }
6393               else
6394                 {
6395 {
6396 return  NULL;
6397
6398 }
6399                 }
6400             case '9':
6401               if (strncmp (KR_keyword, "/dev/st93", 9) == 0)
6402                 {
6403 {
6404 return dev_storage + 714;
6405
6406 }
6407                 }
6408               else
6409                 {
6410 {
6411 return  NULL;
6412
6413 }
6414                 }
6415             case '8':
6416               if (strncmp (KR_keyword, "/dev/st83", 9) == 0)
6417                 {
6418 {
6419 return dev_storage + 704;
6420
6421 }
6422                 }
6423               else
6424                 {
6425 {
6426 return  NULL;
6427
6428 }
6429                 }
6430             case '7':
6431               if (strncmp (KR_keyword, "/dev/st73", 9) == 0)
6432                 {
6433 {
6434 return dev_storage + 694;
6435
6436 }
6437                 }
6438               else
6439                 {
6440 {
6441 return  NULL;
6442
6443 }
6444                 }
6445             case '6':
6446               if (strncmp (KR_keyword, "/dev/st63", 9) == 0)
6447                 {
6448 {
6449 return dev_storage + 684;
6450
6451 }
6452                 }
6453               else
6454                 {
6455 {
6456 return  NULL;
6457
6458 }
6459                 }
6460             case '5':
6461               if (strncmp (KR_keyword, "/dev/st53", 9) == 0)
6462                 {
6463 {
6464 return dev_storage + 674;
6465
6466 }
6467                 }
6468               else
6469                 {
6470 {
6471 return  NULL;
6472
6473 }
6474                 }
6475             case '4':
6476               if (strncmp (KR_keyword, "/dev/st43", 9) == 0)
6477                 {
6478 {
6479 return dev_storage + 664;
6480
6481 }
6482                 }
6483               else
6484                 {
6485 {
6486 return  NULL;
6487
6488 }
6489                 }
6490             case '3':
6491               if (strncmp (KR_keyword, "/dev/st33", 9) == 0)
6492                 {
6493 {
6494 return dev_storage + 654;
6495
6496 }
6497                 }
6498               else
6499                 {
6500 {
6501 return  NULL;
6502
6503 }
6504                 }
6505             case '2':
6506               if (strncmp (KR_keyword, "/dev/st23", 9) == 0)
6507                 {
6508 {
6509 return dev_storage + 644;
6510
6511 }
6512                 }
6513               else
6514                 {
6515 {
6516 return  NULL;
6517
6518 }
6519                 }
6520             case '1':
6521               switch (KR_keyword [6])
6522                 {
6523                 case 't':
6524                   if (strncmp (KR_keyword, "/dev/st13", 9) == 0)
6525                     {
6526 {
6527 return dev_storage + 634;
6528
6529 }
6530                     }
6531                   else
6532                     {
6533 {
6534 return  NULL;
6535
6536 }
6537                     }
6538                 case 'r':
6539                   if (strncmp (KR_keyword, "/dev/sr13", 9) == 0)
6540                     {
6541 {
6542 return dev_storage + 618;
6543
6544 }
6545                     }
6546                   else
6547                     {
6548 {
6549 return  NULL;
6550
6551 }
6552                     }
6553                 case 'd':
6554                   if (strncmp (KR_keyword, "/dev/fd13", 9) == 0)
6555                     {
6556 {
6557 return dev_storage + 34;
6558
6559 }
6560                     }
6561                   else
6562                     {
6563 {
6564 return  NULL;
6565
6566 }
6567                     }
6568                 default:
6569 {
6570 return  NULL;
6571
6572 }
6573                 }
6574             default:
6575 {
6576 return  NULL;
6577
6578 }
6579             }
6580         case '2':
6581           switch (KR_keyword [7])
6582             {
6583             case 'z':
6584               if (strncmp (KR_keyword, "/dev/sdz2", 9) == 0)
6585                 {
6586 {
6587 return dev_storage + 591;
6588
6589 }
6590                 }
6591               else
6592                 {
6593 {
6594 return  NULL;
6595
6596 }
6597                 }
6598             case 'y':
6599               switch (KR_keyword [5])
6600                 {
6601                 case 't':
6602                   if (strncmp (KR_keyword, "/dev/tty2", 9) == 0)
6603                     {
6604 {
6605 return dev_storage + 752;
6606
6607 }
6608                     }
6609                   else
6610                     {
6611 {
6612 return  NULL;
6613
6614 }
6615                     }
6616                 case 's':
6617                   if (strncmp (KR_keyword, "/dev/sdy2", 9) == 0)
6618                     {
6619 {
6620 return dev_storage + 576;
6621
6622 }
6623                     }
6624                   else
6625                     {
6626 {
6627 return  NULL;
6628
6629 }
6630                     }
6631                 default:
6632 {
6633 return  NULL;
6634
6635 }
6636                 }
6637             case 'x':
6638               if (strncmp (KR_keyword, "/dev/sdx2", 9) == 0)
6639                 {
6640 {
6641 return dev_storage + 561;
6642
6643 }
6644                 }
6645               else
6646                 {
6647 {
6648 return  NULL;
6649
6650 }
6651                 }
6652             case 'w':
6653               if (strncmp (KR_keyword, "/dev/sdw2", 9) == 0)
6654                 {
6655 {
6656 return dev_storage + 546;
6657
6658 }
6659                 }
6660               else
6661                 {
6662 {
6663 return  NULL;
6664
6665 }
6666                 }
6667             case 'v':
6668               if (strncmp (KR_keyword, "/dev/sdv2", 9) == 0)
6669                 {
6670 {
6671 return dev_storage + 531;
6672
6673 }
6674                 }
6675               else
6676                 {
6677 {
6678 return  NULL;
6679
6680 }
6681                 }
6682             case 'u':
6683               if (strncmp (KR_keyword, "/dev/sdu2", 9) == 0)
6684                 {
6685 {
6686 return dev_storage + 516;
6687
6688 }
6689                 }
6690               else
6691                 {
6692 {
6693 return  NULL;
6694
6695 }
6696                 }
6697             case 't':
6698               switch (KR_keyword [5])
6699                 {
6700                 case 's':
6701                   if (strncmp (KR_keyword, "/dev/sdt2", 9) == 0)
6702                     {
6703 {
6704 return dev_storage + 501;
6705
6706 }
6707                     }
6708                   else
6709                     {
6710 {
6711 return  NULL;
6712
6713 }
6714                     }
6715                 case 'n':
6716                   if (strncmp (KR_keyword, "/dev/nst2", 9) == 0)
6717                     {
6718 {
6719 return dev_storage + 42;
6720
6721 }
6722                     }
6723                   else
6724                     {
6725 {
6726 return  NULL;
6727
6728 }
6729                     }
6730                 default:
6731 {
6732 return  NULL;
6733
6734 }
6735                 }
6736             case 's':
6737               if (strncmp (KR_keyword, "/dev/sds2", 9) == 0)
6738                 {
6739 {
6740 return dev_storage + 486;
6741
6742 }
6743                 }
6744               else
6745                 {
6746 {
6747 return  NULL;
6748
6749 }
6750                 }
6751             case 'r':
6752               if (strncmp (KR_keyword, "/dev/sdr2", 9) == 0)
6753                 {
6754 {
6755 return dev_storage + 471;
6756
6757 }
6758                 }
6759               else
6760                 {
6761 {
6762 return  NULL;
6763
6764 }
6765                 }
6766             case 'q':
6767               if (strncmp (KR_keyword, "/dev/sdq2", 9) == 0)
6768                 {
6769 {
6770 return dev_storage + 456;
6771
6772 }
6773                 }
6774               else
6775                 {
6776 {
6777 return  NULL;
6778
6779 }
6780                 }
6781             case 'p':
6782               if (strncmp (KR_keyword, "/dev/sdp2", 9) == 0)
6783                 {
6784 {
6785 return dev_storage + 441;
6786
6787 }
6788                 }
6789               else
6790                 {
6791 {
6792 return  NULL;
6793
6794 }
6795                 }
6796             case 'o':
6797               if (strncmp (KR_keyword, "/dev/sdo2", 9) == 0)
6798                 {
6799 {
6800 return dev_storage + 426;
6801
6802 }
6803                 }
6804               else
6805                 {
6806 {
6807 return  NULL;
6808
6809 }
6810                 }
6811             case 'n':
6812               if (strncmp (KR_keyword, "/dev/sdn2", 9) == 0)
6813                 {
6814 {
6815 return dev_storage + 411;
6816
6817 }
6818                 }
6819               else
6820                 {
6821 {
6822 return  NULL;
6823
6824 }
6825                 }
6826             case 'm':
6827               switch (KR_keyword [5])
6828                 {
6829                 case 's':
6830                   if (strncmp (KR_keyword, "/dev/sdm2", 9) == 0)
6831                     {
6832 {
6833 return dev_storage + 396;
6834
6835 }
6836                     }
6837                   else
6838                     {
6839 {
6840 return  NULL;
6841
6842 }
6843                     }
6844                 case 'c':
6845                   if (strncmp (KR_keyword, "/dev/com2", 9) == 0)
6846                     {
6847 {
6848 return dev_storage + 2;
6849
6850 }
6851                     }
6852                   else
6853                     {
6854 {
6855 return  NULL;
6856
6857 }
6858                     }
6859                 default:
6860 {
6861 return  NULL;
6862
6863 }
6864                 }
6865             case 'l':
6866               if (strncmp (KR_keyword, "/dev/sdl2", 9) == 0)
6867                 {
6868 {
6869 return dev_storage + 381;
6870
6871 }
6872                 }
6873               else
6874                 {
6875 {
6876 return  NULL;
6877
6878 }
6879                 }
6880             case 'k':
6881               if (strncmp (KR_keyword, "/dev/sdk2", 9) == 0)
6882                 {
6883 {
6884 return dev_storage + 366;
6885
6886 }
6887                 }
6888               else
6889                 {
6890 {
6891 return  NULL;
6892
6893 }
6894                 }
6895             case 'j':
6896               if (strncmp (KR_keyword, "/dev/sdj2", 9) == 0)
6897                 {
6898 {
6899 return dev_storage + 351;
6900
6901 }
6902                 }
6903               else
6904                 {
6905 {
6906 return  NULL;
6907
6908 }
6909                 }
6910             case 'i':
6911               if (strncmp (KR_keyword, "/dev/sdi2", 9) == 0)
6912                 {
6913 {
6914 return dev_storage + 336;
6915
6916 }
6917                 }
6918               else
6919                 {
6920 {
6921 return  NULL;
6922
6923 }
6924                 }
6925             case 'h':
6926               if (strncmp (KR_keyword, "/dev/sdh2", 9) == 0)
6927                 {
6928 {
6929 return dev_storage + 321;
6930
6931 }
6932                 }
6933               else
6934                 {
6935 {
6936 return  NULL;
6937
6938 }
6939                 }
6940             case 'g':
6941               if (strncmp (KR_keyword, "/dev/sdg2", 9) == 0)
6942                 {
6943 {
6944 return dev_storage + 306;
6945
6946 }
6947                 }
6948               else
6949                 {
6950 {
6951 return  NULL;
6952
6953 }
6954                 }
6955             case 'f':
6956               if (strncmp (KR_keyword, "/dev/sdf2", 9) == 0)
6957                 {
6958 {
6959 return dev_storage + 291;
6960
6961 }
6962                 }
6963               else
6964                 {
6965 {
6966 return  NULL;
6967
6968 }
6969                 }
6970             case 'e':
6971               if (strncmp (KR_keyword, "/dev/sde2", 9) == 0)
6972                 {
6973 {
6974 return dev_storage + 276;
6975
6976 }
6977                 }
6978               else
6979                 {
6980 {
6981 return  NULL;
6982
6983 }
6984                 }
6985             case 'd':
6986               switch (KR_keyword [6])
6987                 {
6988                 case 'd':
6989                   if (strncmp (KR_keyword, "/dev/sdd2", 9) == 0)
6990                     {
6991 {
6992 return dev_storage + 261;
6993
6994 }
6995                     }
6996                   else
6997                     {
6998 {
6999 return  NULL;
7000
7001 }
7002                     }
7003                 case 'c':
7004                   if (strncmp (KR_keyword, "/dev/scd2", 9) == 0)
7005                     {
7006 {
7007 return dev_storage + 175;
7008
7009 }
7010                     }
7011                   else
7012                     {
7013 {
7014 return  NULL;
7015
7016 }
7017                     }
7018                 default:
7019 {
7020 return  NULL;
7021
7022 }
7023                 }
7024             case 'c':
7025               if (strncmp (KR_keyword, "/dev/sdc2", 9) == 0)
7026                 {
7027 {
7028 return dev_storage + 246;
7029
7030 }
7031                 }
7032               else
7033                 {
7034 {
7035 return  NULL;
7036
7037 }
7038                 }
7039             case 'b':
7040               if (strncmp (KR_keyword, "/dev/sdb2", 9) == 0)
7041                 {
7042 {
7043 return dev_storage + 231;
7044
7045 }
7046                 }
7047               else
7048                 {
7049 {
7050 return  NULL;
7051
7052 }
7053                 }
7054             case 'a':
7055               if (strncmp (KR_keyword, "/dev/sda2", 9) == 0)
7056                 {
7057 {
7058 return dev_storage + 216;
7059
7060 }
7061                 }
7062               else
7063                 {
7064 {
7065 return  NULL;
7066
7067 }
7068                 }
7069             case '9':
7070               if (strncmp (KR_keyword, "/dev/st92", 9) == 0)
7071                 {
7072 {
7073 return dev_storage + 713;
7074
7075 }
7076                 }
7077               else
7078                 {
7079 {
7080 return  NULL;
7081
7082 }
7083                 }
7084             case '8':
7085               if (strncmp (KR_keyword, "/dev/st82", 9) == 0)
7086                 {
7087 {
7088 return dev_storage + 703;
7089
7090 }
7091                 }
7092               else
7093                 {
7094 {
7095 return  NULL;
7096
7097 }
7098                 }
7099             case '7':
7100               if (strncmp (KR_keyword, "/dev/st72", 9) == 0)
7101                 {
7102 {
7103 return dev_storage + 693;
7104
7105 }
7106                 }
7107               else
7108                 {
7109 {
7110 return  NULL;
7111
7112 }
7113                 }
7114             case '6':
7115               if (strncmp (KR_keyword, "/dev/st62", 9) == 0)
7116                 {
7117 {
7118 return dev_storage + 683;
7119
7120 }
7121                 }
7122               else
7123                 {
7124 {
7125 return  NULL;
7126
7127 }
7128                 }
7129             case '5':
7130               if (strncmp (KR_keyword, "/dev/st52", 9) == 0)
7131                 {
7132 {
7133 return dev_storage + 673;
7134
7135 }
7136                 }
7137               else
7138                 {
7139 {
7140 return  NULL;
7141
7142 }
7143                 }
7144             case '4':
7145               if (strncmp (KR_keyword, "/dev/st42", 9) == 0)
7146                 {
7147 {
7148 return dev_storage + 663;
7149
7150 }
7151                 }
7152               else
7153                 {
7154 {
7155 return  NULL;
7156
7157 }
7158                 }
7159             case '3':
7160               if (strncmp (KR_keyword, "/dev/st32", 9) == 0)
7161                 {
7162 {
7163 return dev_storage + 653;
7164
7165 }
7166                 }
7167               else
7168                 {
7169 {
7170 return  NULL;
7171
7172 }
7173                 }
7174             case '2':
7175               if (strncmp (KR_keyword, "/dev/st22", 9) == 0)
7176                 {
7177 {
7178 return dev_storage + 643;
7179
7180 }
7181                 }
7182               else
7183                 {
7184 {
7185 return  NULL;
7186
7187 }
7188                 }
7189             case '1':
7190               switch (KR_keyword [6])
7191                 {
7192                 case 't':
7193                   if (strncmp (KR_keyword, "/dev/st12", 9) == 0)
7194                     {
7195 {
7196 return dev_storage + 633;
7197
7198 }
7199                     }
7200                   else
7201                     {
7202 {
7203 return  NULL;
7204
7205 }
7206                     }
7207                 case 'r':
7208                   if (strncmp (KR_keyword, "/dev/sr12", 9) == 0)
7209                     {
7210 {
7211 return dev_storage + 617;
7212
7213 }
7214                     }
7215                   else
7216                     {
7217 {
7218 return  NULL;
7219
7220 }
7221                     }
7222                 case 'd':
7223                   if (strncmp (KR_keyword, "/dev/fd12", 9) == 0)
7224                     {
7225 {
7226 return dev_storage + 33;
7227
7228 }
7229                     }
7230                   else
7231                     {
7232 {
7233 return  NULL;
7234
7235 }
7236                     }
7237                 default:
7238 {
7239 return  NULL;
7240
7241 }
7242                 }
7243             default:
7244 {
7245 return  NULL;
7246
7247 }
7248             }
7249         case '1':
7250           switch (KR_keyword [7])
7251             {
7252             case 'z':
7253               if (strncmp (KR_keyword, "/dev/sdz1", 9) == 0)
7254                 {
7255 {
7256 return dev_storage + 590;
7257
7258 }
7259                 }
7260               else
7261                 {
7262 {
7263 return  NULL;
7264
7265 }
7266                 }
7267             case 'y':
7268               switch (KR_keyword [5])
7269                 {
7270                 case 't':
7271                   if (strncmp (KR_keyword, "/dev/tty1", 9) == 0)
7272                     {
7273 {
7274 return dev_storage + 751;
7275
7276 }
7277                     }
7278                   else
7279                     {
7280 {
7281 return  NULL;
7282
7283 }
7284                     }
7285                 case 's':
7286                   if (strncmp (KR_keyword, "/dev/sdy1", 9) == 0)
7287                     {
7288 {
7289 return dev_storage + 575;
7290
7291 }
7292                     }
7293                   else
7294                     {
7295 {
7296 return  NULL;
7297
7298 }
7299                     }
7300                 default:
7301 {
7302 return  NULL;
7303
7304 }
7305                 }
7306             case 'x':
7307               if (strncmp (KR_keyword, "/dev/sdx1", 9) == 0)
7308                 {
7309 {
7310 return dev_storage + 560;
7311
7312 }
7313                 }
7314               else
7315                 {
7316 {
7317 return  NULL;
7318
7319 }
7320                 }
7321             case 'w':
7322               if (strncmp (KR_keyword, "/dev/sdw1", 9) == 0)
7323                 {
7324 {
7325 return dev_storage + 545;
7326
7327 }
7328                 }
7329               else
7330                 {
7331 {
7332 return  NULL;
7333
7334 }
7335                 }
7336             case 'v':
7337               if (strncmp (KR_keyword, "/dev/sdv1", 9) == 0)
7338                 {
7339 {
7340 return dev_storage + 530;
7341
7342 }
7343                 }
7344               else
7345                 {
7346 {
7347 return  NULL;
7348
7349 }
7350                 }
7351             case 'u':
7352               if (strncmp (KR_keyword, "/dev/sdu1", 9) == 0)
7353                 {
7354 {
7355 return dev_storage + 515;
7356
7357 }
7358                 }
7359               else
7360                 {
7361 {
7362 return  NULL;
7363
7364 }
7365                 }
7366             case 't':
7367               switch (KR_keyword [5])
7368                 {
7369                 case 's':
7370                   if (strncmp (KR_keyword, "/dev/sdt1", 9) == 0)
7371                     {
7372 {
7373 return dev_storage + 500;
7374
7375 }
7376                     }
7377                   else
7378                     {
7379 {
7380 return  NULL;
7381
7382 }
7383                     }
7384                 case 'n':
7385                   if (strncmp (KR_keyword, "/dev/nst1", 9) == 0)
7386                     {
7387 {
7388 return dev_storage + 41;
7389
7390 }
7391                     }
7392                   else
7393                     {
7394 {
7395 return  NULL;
7396
7397 }
7398                     }
7399                 default:
7400 {
7401 return  NULL;
7402
7403 }
7404                 }
7405             case 's':
7406               if (strncmp (KR_keyword, "/dev/sds1", 9) == 0)
7407                 {
7408 {
7409 return dev_storage + 485;
7410
7411 }
7412                 }
7413               else
7414                 {
7415 {
7416 return  NULL;
7417
7418 }
7419                 }
7420             case 'r':
7421               if (strncmp (KR_keyword, "/dev/sdr1", 9) == 0)
7422                 {
7423 {
7424 return dev_storage + 470;
7425
7426 }
7427                 }
7428               else
7429                 {
7430 {
7431 return  NULL;
7432
7433 }
7434                 }
7435             case 'q':
7436               if (strncmp (KR_keyword, "/dev/sdq1", 9) == 0)
7437                 {
7438 {
7439 return dev_storage + 455;
7440
7441 }
7442                 }
7443               else
7444                 {
7445 {
7446 return  NULL;
7447
7448 }
7449                 }
7450             case 'p':
7451               if (strncmp (KR_keyword, "/dev/sdp1", 9) == 0)
7452                 {
7453 {
7454 return dev_storage + 440;
7455
7456 }
7457                 }
7458               else
7459                 {
7460 {
7461 return  NULL;
7462
7463 }
7464                 }
7465             case 'o':
7466               if (strncmp (KR_keyword, "/dev/sdo1", 9) == 0)
7467                 {
7468 {
7469 return dev_storage + 425;
7470
7471 }
7472                 }
7473               else
7474                 {
7475 {
7476 return  NULL;
7477
7478 }
7479                 }
7480             case 'n':
7481               if (strncmp (KR_keyword, "/dev/sdn1", 9) == 0)
7482                 {
7483 {
7484 return dev_storage + 410;
7485
7486 }
7487                 }
7488               else
7489                 {
7490 {
7491 return  NULL;
7492
7493 }
7494                 }
7495             case 'm':
7496               switch (KR_keyword [5])
7497                 {
7498                 case 's':
7499                   if (strncmp (KR_keyword, "/dev/sdm1", 9) == 0)
7500                     {
7501 {
7502 return dev_storage + 395;
7503
7504 }
7505                     }
7506                   else
7507                     {
7508 {
7509 return  NULL;
7510
7511 }
7512                     }
7513                 case 'c':
7514                   if (strncmp (KR_keyword, "/dev/com1", 9) == 0)
7515                     {
7516 {
7517 return dev_storage + 1;
7518
7519 }
7520                     }
7521                   else
7522                     {
7523 {
7524 return  NULL;
7525
7526 }
7527                     }
7528                 default:
7529 {
7530 return  NULL;
7531
7532 }
7533                 }
7534             case 'l':
7535               if (strncmp (KR_keyword, "/dev/sdl1", 9) == 0)
7536                 {
7537 {
7538 return dev_storage + 380;
7539
7540 }
7541                 }
7542               else
7543                 {
7544 {
7545 return  NULL;
7546
7547 }
7548                 }
7549             case 'k':
7550               if (strncmp (KR_keyword, "/dev/sdk1", 9) == 0)
7551                 {
7552 {
7553 return dev_storage + 365;
7554
7555 }
7556                 }
7557               else
7558                 {
7559 {
7560 return  NULL;
7561
7562 }
7563                 }
7564             case 'j':
7565               if (strncmp (KR_keyword, "/dev/sdj1", 9) == 0)
7566                 {
7567 {
7568 return dev_storage + 350;
7569
7570 }
7571                 }
7572               else
7573                 {
7574 {
7575 return  NULL;
7576
7577 }
7578                 }
7579             case 'i':
7580               if (strncmp (KR_keyword, "/dev/sdi1", 9) == 0)
7581                 {
7582 {
7583 return dev_storage + 335;
7584
7585 }
7586                 }
7587               else
7588                 {
7589 {
7590 return  NULL;
7591
7592 }
7593                 }
7594             case 'h':
7595               if (strncmp (KR_keyword, "/dev/sdh1", 9) == 0)
7596                 {
7597 {
7598 return dev_storage + 320;
7599
7600 }
7601                 }
7602               else
7603                 {
7604 {
7605 return  NULL;
7606
7607 }
7608                 }
7609             case 'g':
7610               if (strncmp (KR_keyword, "/dev/sdg1", 9) == 0)
7611                 {
7612 {
7613 return dev_storage + 305;
7614
7615 }
7616                 }
7617               else
7618                 {
7619 {
7620 return  NULL;
7621
7622 }
7623                 }
7624             case 'f':
7625               if (strncmp (KR_keyword, "/dev/sdf1", 9) == 0)
7626                 {
7627 {
7628 return dev_storage + 290;
7629
7630 }
7631                 }
7632               else
7633                 {
7634 {
7635 return  NULL;
7636
7637 }
7638                 }
7639             case 'e':
7640               if (strncmp (KR_keyword, "/dev/sde1", 9) == 0)
7641                 {
7642 {
7643 return dev_storage + 275;
7644
7645 }
7646                 }
7647               else
7648                 {
7649 {
7650 return  NULL;
7651
7652 }
7653                 }
7654             case 'd':
7655               switch (KR_keyword [6])
7656                 {
7657                 case 'd':
7658                   if (strncmp (KR_keyword, "/dev/sdd1", 9) == 0)
7659                     {
7660 {
7661 return dev_storage + 260;
7662
7663 }
7664                     }
7665                   else
7666                     {
7667 {
7668 return  NULL;
7669
7670 }
7671                     }
7672                 case 'c':
7673                   if (strncmp (KR_keyword, "/dev/scd1", 9) == 0)
7674                     {
7675 {
7676 return dev_storage + 174;
7677
7678 }
7679                     }
7680                   else
7681                     {
7682 {
7683 return  NULL;
7684
7685 }
7686                     }
7687                 default:
7688 {
7689 return  NULL;
7690
7691 }
7692                 }
7693             case 'c':
7694               if (strncmp (KR_keyword, "/dev/sdc1", 9) == 0)
7695                 {
7696 {
7697 return dev_storage + 245;
7698
7699 }
7700                 }
7701               else
7702                 {
7703 {
7704 return  NULL;
7705
7706 }
7707                 }
7708             case 'b':
7709               if (strncmp (KR_keyword, "/dev/sdb1", 9) == 0)
7710                 {
7711 {
7712 return dev_storage + 230;
7713
7714 }
7715                 }
7716               else
7717                 {
7718 {
7719 return  NULL;
7720
7721 }
7722                 }
7723             case 'a':
7724               if (strncmp (KR_keyword, "/dev/sda1", 9) == 0)
7725                 {
7726 {
7727 return dev_storage + 215;
7728
7729 }
7730                 }
7731               else
7732                 {
7733 {
7734 return  NULL;
7735
7736 }
7737                 }
7738             case '9':
7739               if (strncmp (KR_keyword, "/dev/st91", 9) == 0)
7740                 {
7741 {
7742 return dev_storage + 712;
7743
7744 }
7745                 }
7746               else
7747                 {
7748 {
7749 return  NULL;
7750
7751 }
7752                 }
7753             case '8':
7754               if (strncmp (KR_keyword, "/dev/st81", 9) == 0)
7755                 {
7756 {
7757 return dev_storage + 702;
7758
7759 }
7760                 }
7761               else
7762                 {
7763 {
7764 return  NULL;
7765
7766 }
7767                 }
7768             case '7':
7769               if (strncmp (KR_keyword, "/dev/st71", 9) == 0)
7770                 {
7771 {
7772 return dev_storage + 692;
7773
7774 }
7775                 }
7776               else
7777                 {
7778 {
7779 return  NULL;
7780
7781 }
7782                 }
7783             case '6':
7784               if (strncmp (KR_keyword, "/dev/st61", 9) == 0)
7785                 {
7786 {
7787 return dev_storage + 682;
7788
7789 }
7790                 }
7791               else
7792                 {
7793 {
7794 return  NULL;
7795
7796 }
7797                 }
7798             case '5':
7799               if (strncmp (KR_keyword, "/dev/st51", 9) == 0)
7800                 {
7801 {
7802 return dev_storage + 672;
7803
7804 }
7805                 }
7806               else
7807                 {
7808 {
7809 return  NULL;
7810
7811 }
7812                 }
7813             case '4':
7814               if (strncmp (KR_keyword, "/dev/st41", 9) == 0)
7815                 {
7816 {
7817 return dev_storage + 662;
7818
7819 }
7820                 }
7821               else
7822                 {
7823 {
7824 return  NULL;
7825
7826 }
7827                 }
7828             case '3':
7829               if (strncmp (KR_keyword, "/dev/st31", 9) == 0)
7830                 {
7831 {
7832 return dev_storage + 652;
7833
7834 }
7835                 }
7836               else
7837                 {
7838 {
7839 return  NULL;
7840
7841 }
7842                 }
7843             case '2':
7844               if (strncmp (KR_keyword, "/dev/st21", 9) == 0)
7845                 {
7846 {
7847 return dev_storage + 642;
7848
7849 }
7850                 }
7851               else
7852                 {
7853 {
7854 return  NULL;
7855
7856 }
7857                 }
7858             case '1':
7859               switch (KR_keyword [6])
7860                 {
7861                 case 't':
7862                   if (strncmp (KR_keyword, "/dev/st11", 9) == 0)
7863                     {
7864 {
7865 return dev_storage + 632;
7866
7867 }
7868                     }
7869                   else
7870                     {
7871 {
7872 return  NULL;
7873
7874 }
7875                     }
7876                 case 'r':
7877                   if (strncmp (KR_keyword, "/dev/sr11", 9) == 0)
7878                     {
7879 {
7880 return dev_storage + 616;
7881
7882 }
7883                     }
7884                   else
7885                     {
7886 {
7887 return  NULL;
7888
7889 }
7890                     }
7891                 case 'd':
7892                   if (strncmp (KR_keyword, "/dev/fd11", 9) == 0)
7893                     {
7894 {
7895 return dev_storage + 32;
7896
7897 }
7898                     }
7899                   else
7900                     {
7901 {
7902 return  NULL;
7903
7904 }
7905                     }
7906                 default:
7907 {
7908 return  NULL;
7909
7910 }
7911                 }
7912             default:
7913 {
7914 return  NULL;
7915
7916 }
7917             }
7918         case '0':
7919           switch (KR_keyword [7])
7920             {
7921             case 'y':
7922               if (strncmp (KR_keyword, "/dev/tty0", 9) == 0)
7923                 {
7924 {
7925 return dev_storage + 750;
7926
7927 }
7928                 }
7929               else
7930                 {
7931 {
7932 return  NULL;
7933
7934 }
7935                 }
7936             case 't':
7937               if (strncmp (KR_keyword, "/dev/nst0", 9) == 0)
7938                 {
7939 {
7940 return dev_storage + 40;
7941
7942 }
7943                 }
7944               else
7945                 {
7946 {
7947 return  NULL;
7948
7949 }
7950                 }
7951             case 'd':
7952               if (strncmp (KR_keyword, "/dev/scd0", 9) == 0)
7953                 {
7954 {
7955 return dev_storage + 173;
7956
7957 }
7958                 }
7959               else
7960                 {
7961 {
7962 return  NULL;
7963
7964 }
7965                 }
7966             case '9':
7967               if (strncmp (KR_keyword, "/dev/st90", 9) == 0)
7968                 {
7969 {
7970 return dev_storage + 711;
7971
7972 }
7973                 }
7974               else
7975                 {
7976 {
7977 return  NULL;
7978
7979 }
7980                 }
7981             case '8':
7982               if (strncmp (KR_keyword, "/dev/st80", 9) == 0)
7983                 {
7984 {
7985 return dev_storage + 701;
7986
7987 }
7988                 }
7989               else
7990                 {
7991 {
7992 return  NULL;
7993
7994 }
7995                 }
7996             case '7':
7997               if (strncmp (KR_keyword, "/dev/st70", 9) == 0)
7998                 {
7999 {
8000 return dev_storage + 691;
8001
8002 }
8003                 }
8004               else
8005                 {
8006 {
8007 return  NULL;
8008
8009 }
8010                 }
8011             case '6':
8012               if (strncmp (KR_keyword, "/dev/st60", 9) == 0)
8013                 {
8014 {
8015 return dev_storage + 681;
8016
8017 }
8018                 }
8019               else
8020                 {
8021 {
8022 return  NULL;
8023
8024 }
8025                 }
8026             case '5':
8027               if (strncmp (KR_keyword, "/dev/st50", 9) == 0)
8028                 {
8029 {
8030 return dev_storage + 671;
8031
8032 }
8033                 }
8034               else
8035                 {
8036 {
8037 return  NULL;
8038
8039 }
8040                 }
8041             case '4':
8042               if (strncmp (KR_keyword, "/dev/st40", 9) == 0)
8043                 {
8044 {
8045 return dev_storage + 661;
8046
8047 }
8048                 }
8049               else
8050                 {
8051 {
8052 return  NULL;
8053
8054 }
8055                 }
8056             case '3':
8057               if (strncmp (KR_keyword, "/dev/st30", 9) == 0)
8058                 {
8059 {
8060 return dev_storage + 651;
8061
8062 }
8063                 }
8064               else
8065                 {
8066 {
8067 return  NULL;
8068
8069 }
8070                 }
8071             case '2':
8072               if (strncmp (KR_keyword, "/dev/st20", 9) == 0)
8073                 {
8074 {
8075 return dev_storage + 641;
8076
8077 }
8078                 }
8079               else
8080                 {
8081 {
8082 return  NULL;
8083
8084 }
8085                 }
8086             case '1':
8087               switch (KR_keyword [6])
8088                 {
8089                 case 't':
8090                   if (strncmp (KR_keyword, "/dev/st10", 9) == 0)
8091                     {
8092 {
8093 return dev_storage + 631;
8094
8095 }
8096                     }
8097                   else
8098                     {
8099 {
8100 return  NULL;
8101
8102 }
8103                     }
8104                 case 'r':
8105                   if (strncmp (KR_keyword, "/dev/sr10", 9) == 0)
8106                     {
8107 {
8108 return dev_storage + 615;
8109
8110 }
8111                     }
8112                   else
8113                     {
8114 {
8115 return  NULL;
8116
8117 }
8118                     }
8119                 case 'd':
8120                   if (strncmp (KR_keyword, "/dev/fd10", 9) == 0)
8121                     {
8122 {
8123 return dev_storage + 31;
8124
8125 }
8126                     }
8127                   else
8128                     {
8129 {
8130 return  NULL;
8131
8132 }
8133                     }
8134                 default:
8135 {
8136 return  NULL;
8137
8138 }
8139                 }
8140             default:
8141 {
8142 return  NULL;
8143
8144 }
8145             }
8146         default:
8147 {
8148 return  NULL;
8149
8150 }
8151         }
8152     case 10:
8153       switch (KR_keyword [9])
8154         {
8155         case 'n':
8156           if (strncmp (KR_keyword, "/dev/conin", 10) == 0)
8157             {
8158 {
8159 return dev_storage + 17;
8160
8161 }
8162             }
8163           else
8164             {
8165 {
8166 return  NULL;
8167
8168 }
8169             }
8170         case '9':
8171           switch (KR_keyword [8])
8172             {
8173             case 'S':
8174               if (strncmp (KR_keyword, "/dev/ttyS9", 10) == 0)
8175                 {
8176 {
8177 return dev_storage + 823;
8178
8179 }
8180                 }
8181               else
8182                 {
8183 {
8184 return  NULL;
8185
8186 }
8187                 }
8188             case '9':
8189               if (strncmp (KR_keyword, "/dev/nst99", 10) == 0)
8190                 {
8191 {
8192 return dev_storage + 139;
8193
8194 }
8195                 }
8196               else
8197                 {
8198 {
8199 return  NULL;
8200
8201 }
8202                 }
8203             case '8':
8204               if (strncmp (KR_keyword, "/dev/nst89", 10) == 0)
8205                 {
8206 {
8207 return dev_storage + 129;
8208
8209 }
8210                 }
8211               else
8212                 {
8213 {
8214 return  NULL;
8215
8216 }
8217                 }
8218             case '7':
8219               if (strncmp (KR_keyword, "/dev/nst79", 10) == 0)
8220                 {
8221 {
8222 return dev_storage + 119;
8223
8224 }
8225                 }
8226               else
8227                 {
8228 {
8229 return  NULL;
8230
8231 }
8232                 }
8233             case '6':
8234               if (strncmp (KR_keyword, "/dev/nst69", 10) == 0)
8235                 {
8236 {
8237 return dev_storage + 109;
8238
8239 }
8240                 }
8241               else
8242                 {
8243 {
8244 return  NULL;
8245
8246 }
8247                 }
8248             case '5':
8249               switch (KR_keyword [5])
8250                 {
8251                 case 't':
8252                   if (strncmp (KR_keyword, "/dev/tty59", 10) == 0)
8253                     {
8254 {
8255 return dev_storage + 809;
8256
8257 }
8258                     }
8259                   else
8260                     {
8261 {
8262 return  NULL;
8263
8264 }
8265                     }
8266                 case 'n':
8267                   if (strncmp (KR_keyword, "/dev/nst59", 10) == 0)
8268                     {
8269 {
8270 return dev_storage + 99;
8271
8272 }
8273                     }
8274                   else
8275                     {
8276 {
8277 return  NULL;
8278
8279 }
8280                     }
8281                 default:
8282 {
8283 return  NULL;
8284
8285 }
8286                 }
8287             case '4':
8288               switch (KR_keyword [5])
8289                 {
8290                 case 't':
8291                   if (strncmp (KR_keyword, "/dev/tty49", 10) == 0)
8292                     {
8293 {
8294 return dev_storage + 799;
8295
8296 }
8297                     }
8298                   else
8299                     {
8300 {
8301 return  NULL;
8302
8303 }
8304                     }
8305                 case 'n':
8306                   if (strncmp (KR_keyword, "/dev/nst49", 10) == 0)
8307                     {
8308 {
8309 return dev_storage + 89;
8310
8311 }
8312                     }
8313                   else
8314                     {
8315 {
8316 return  NULL;
8317
8318 }
8319                     }
8320                 default:
8321 {
8322 return  NULL;
8323
8324 }
8325                 }
8326             case '3':
8327               switch (KR_keyword [5])
8328                 {
8329                 case 't':
8330                   if (strncmp (KR_keyword, "/dev/tty39", 10) == 0)
8331                     {
8332 {
8333 return dev_storage + 789;
8334
8335 }
8336                     }
8337                   else
8338                     {
8339 {
8340 return  NULL;
8341
8342 }
8343                     }
8344                 case 'n':
8345                   if (strncmp (KR_keyword, "/dev/nst39", 10) == 0)
8346                     {
8347 {
8348 return dev_storage + 79;
8349
8350 }
8351                     }
8352                   else
8353                     {
8354 {
8355 return  NULL;
8356
8357 }
8358                     }
8359                 default:
8360 {
8361 return  NULL;
8362
8363 }
8364                 }
8365             case '2':
8366               switch (KR_keyword [5])
8367                 {
8368                 case 't':
8369                   if (strncmp (KR_keyword, "/dev/tty29", 10) == 0)
8370                     {
8371 {
8372 return dev_storage + 779;
8373
8374 }
8375                     }
8376                   else
8377                     {
8378 {
8379 return  NULL;
8380
8381 }
8382                     }
8383                 case 'n':
8384                   if (strncmp (KR_keyword, "/dev/nst29", 10) == 0)
8385                     {
8386 {
8387 return dev_storage + 69;
8388
8389 }
8390                     }
8391                   else
8392                     {
8393 {
8394 return  NULL;
8395
8396 }
8397                     }
8398                 default:
8399 {
8400 return  NULL;
8401
8402 }
8403                 }
8404             case '1':
8405               switch (KR_keyword [5])
8406                 {
8407                 case 't':
8408                   if (strncmp (KR_keyword, "/dev/tty19", 10) == 0)
8409                     {
8410 {
8411 return dev_storage + 769;
8412
8413 }
8414                     }
8415                   else
8416                     {
8417 {
8418 return  NULL;
8419
8420 }
8421                     }
8422                 case 's':
8423                   if (strncmp (KR_keyword, "/dev/st119", 10) == 0)
8424                     {
8425 {
8426 return dev_storage + 740;
8427
8428 }
8429                     }
8430                   else
8431                     {
8432 {
8433 return  NULL;
8434
8435 }
8436                     }
8437                 case 'n':
8438                   if (strncmp (KR_keyword, "/dev/nst19", 10) == 0)
8439                     {
8440 {
8441 return dev_storage + 59;
8442
8443 }
8444                     }
8445                   else
8446                     {
8447 {
8448 return  NULL;
8449
8450 }
8451                     }
8452                 default:
8453 {
8454 return  NULL;
8455
8456 }
8457                 }
8458             case '0':
8459               if (strncmp (KR_keyword, "/dev/st109", 10) == 0)
8460                 {
8461 {
8462 return dev_storage + 730;
8463
8464 }
8465                 }
8466               else
8467                 {
8468 {
8469 return  NULL;
8470
8471 }
8472                 }
8473             default:
8474 {
8475 return  NULL;
8476
8477 }
8478             }
8479         case '8':
8480           switch (KR_keyword [8])
8481             {
8482             case 'S':
8483               if (strncmp (KR_keyword, "/dev/ttyS8", 10) == 0)
8484                 {
8485 {
8486 return dev_storage + 822;
8487
8488 }
8489                 }
8490               else
8491                 {
8492 {
8493 return  NULL;
8494
8495 }
8496                 }
8497             case '9':
8498               if (strncmp (KR_keyword, "/dev/nst98", 10) == 0)
8499                 {
8500 {
8501 return dev_storage + 138;
8502
8503 }
8504                 }
8505               else
8506                 {
8507 {
8508 return  NULL;
8509
8510 }
8511                 }
8512             case '8':
8513               if (strncmp (KR_keyword, "/dev/nst88", 10) == 0)
8514                 {
8515 {
8516 return dev_storage + 128;
8517
8518 }
8519                 }
8520               else
8521                 {
8522 {
8523 return  NULL;
8524
8525 }
8526                 }
8527             case '7':
8528               if (strncmp (KR_keyword, "/dev/nst78", 10) == 0)
8529                 {
8530 {
8531 return dev_storage + 118;
8532
8533 }
8534                 }
8535               else
8536                 {
8537 {
8538 return  NULL;
8539
8540 }
8541                 }
8542             case '6':
8543               if (strncmp (KR_keyword, "/dev/nst68", 10) == 0)
8544                 {
8545 {
8546 return dev_storage + 108;
8547
8548 }
8549                 }
8550               else
8551                 {
8552 {
8553 return  NULL;
8554
8555 }
8556                 }
8557             case '5':
8558               switch (KR_keyword [5])
8559                 {
8560                 case 't':
8561                   if (strncmp (KR_keyword, "/dev/tty58", 10) == 0)
8562                     {
8563 {
8564 return dev_storage + 808;
8565
8566 }
8567                     }
8568                   else
8569                     {
8570 {
8571 return  NULL;
8572
8573 }
8574                     }
8575                 case 'n':
8576                   if (strncmp (KR_keyword, "/dev/nst58", 10) == 0)
8577                     {
8578 {
8579 return dev_storage + 98;
8580
8581 }
8582                     }
8583                   else
8584                     {
8585 {
8586 return  NULL;
8587
8588 }
8589                     }
8590                 default:
8591 {
8592 return  NULL;
8593
8594 }
8595                 }
8596             case '4':
8597               switch (KR_keyword [5])
8598                 {
8599                 case 't':
8600                   if (strncmp (KR_keyword, "/dev/tty48", 10) == 0)
8601                     {
8602 {
8603 return dev_storage + 798;
8604
8605 }
8606                     }
8607                   else
8608                     {
8609 {
8610 return  NULL;
8611
8612 }
8613                     }
8614                 case 'n':
8615                   if (strncmp (KR_keyword, "/dev/nst48", 10) == 0)
8616                     {
8617 {
8618 return dev_storage + 88;
8619
8620 }
8621                     }
8622                   else
8623                     {
8624 {
8625 return  NULL;
8626
8627 }
8628                     }
8629                 default:
8630 {
8631 return  NULL;
8632
8633 }
8634                 }
8635             case '3':
8636               switch (KR_keyword [5])
8637                 {
8638                 case 't':
8639                   if (strncmp (KR_keyword, "/dev/tty38", 10) == 0)
8640                     {
8641 {
8642 return dev_storage + 788;
8643
8644 }
8645                     }
8646                   else
8647                     {
8648 {
8649 return  NULL;
8650
8651 }
8652                     }
8653                 case 'n':
8654                   if (strncmp (KR_keyword, "/dev/nst38", 10) == 0)
8655                     {
8656 {
8657 return dev_storage + 78;
8658
8659 }
8660                     }
8661                   else
8662                     {
8663 {
8664 return  NULL;
8665
8666 }
8667                     }
8668                 default:
8669 {
8670 return  NULL;
8671
8672 }
8673                 }
8674             case '2':
8675               switch (KR_keyword [5])
8676                 {
8677                 case 't':
8678                   if (strncmp (KR_keyword, "/dev/tty28", 10) == 0)
8679                     {
8680 {
8681 return dev_storage + 778;
8682
8683 }
8684                     }
8685                   else
8686                     {
8687 {
8688 return  NULL;
8689
8690 }
8691                     }
8692                 case 'n':
8693                   if (strncmp (KR_keyword, "/dev/nst28", 10) == 0)
8694                     {
8695 {
8696 return dev_storage + 68;
8697
8698 }
8699                     }
8700                   else
8701                     {
8702 {
8703 return  NULL;
8704
8705 }
8706                     }
8707                 default:
8708 {
8709 return  NULL;
8710
8711 }
8712                 }
8713             case '1':
8714               switch (KR_keyword [5])
8715                 {
8716                 case 't':
8717                   if (strncmp (KR_keyword, "/dev/tty18", 10) == 0)
8718                     {
8719 {
8720 return dev_storage + 768;
8721
8722 }
8723                     }
8724                   else
8725                     {
8726 {
8727 return  NULL;
8728
8729 }
8730                     }
8731                 case 's':
8732                   if (strncmp (KR_keyword, "/dev/st118", 10) == 0)
8733                     {
8734 {
8735 return dev_storage + 739;
8736
8737 }
8738                     }
8739                   else
8740                     {
8741 {
8742 return  NULL;
8743
8744 }
8745                     }
8746                 case 'n':
8747                   if (strncmp (KR_keyword, "/dev/nst18", 10) == 0)
8748                     {
8749 {
8750 return dev_storage + 58;
8751
8752 }
8753                     }
8754                   else
8755                     {
8756 {
8757 return  NULL;
8758
8759 }
8760                     }
8761                 default:
8762 {
8763 return  NULL;
8764
8765 }
8766                 }
8767             case '0':
8768               if (strncmp (KR_keyword, "/dev/st108", 10) == 0)
8769                 {
8770 {
8771 return dev_storage + 729;
8772
8773 }
8774                 }
8775               else
8776                 {
8777 {
8778 return  NULL;
8779
8780 }
8781                 }
8782             default:
8783 {
8784 return  NULL;
8785
8786 }
8787             }
8788         case '7':
8789           switch (KR_keyword [8])
8790             {
8791             case 'S':
8792               if (strncmp (KR_keyword, "/dev/ttyS7", 10) == 0)
8793                 {
8794 {
8795 return dev_storage + 821;
8796
8797 }
8798                 }
8799               else
8800                 {
8801 {
8802 return  NULL;
8803
8804 }
8805                 }
8806             case '9':
8807               if (strncmp (KR_keyword, "/dev/nst97", 10) == 0)
8808                 {
8809 {
8810 return dev_storage + 137;
8811
8812 }
8813                 }
8814               else
8815                 {
8816 {
8817 return  NULL;
8818
8819 }
8820                 }
8821             case '8':
8822               if (strncmp (KR_keyword, "/dev/nst87", 10) == 0)
8823                 {
8824 {
8825 return dev_storage + 127;
8826
8827 }
8828                 }
8829               else
8830                 {
8831 {
8832 return  NULL;
8833
8834 }
8835                 }
8836             case '7':
8837               if (strncmp (KR_keyword, "/dev/nst77", 10) == 0)
8838                 {
8839 {
8840 return dev_storage + 117;
8841
8842 }
8843                 }
8844               else
8845                 {
8846 {
8847 return  NULL;
8848
8849 }
8850                 }
8851             case '6':
8852               if (strncmp (KR_keyword, "/dev/nst67", 10) == 0)
8853                 {
8854 {
8855 return dev_storage + 107;
8856
8857 }
8858                 }
8859               else
8860                 {
8861 {
8862 return  NULL;
8863
8864 }
8865                 }
8866             case '5':
8867               switch (KR_keyword [5])
8868                 {
8869                 case 't':
8870                   if (strncmp (KR_keyword, "/dev/tty57", 10) == 0)
8871                     {
8872 {
8873 return dev_storage + 807;
8874
8875 }
8876                     }
8877                   else
8878                     {
8879 {
8880 return  NULL;
8881
8882 }
8883                     }
8884                 case 'n':
8885                   if (strncmp (KR_keyword, "/dev/nst57", 10) == 0)
8886                     {
8887 {
8888 return dev_storage + 97;
8889
8890 }
8891                     }
8892                   else
8893                     {
8894 {
8895 return  NULL;
8896
8897 }
8898                     }
8899                 default:
8900 {
8901 return  NULL;
8902
8903 }
8904                 }
8905             case '4':
8906               switch (KR_keyword [5])
8907                 {
8908                 case 't':
8909                   if (strncmp (KR_keyword, "/dev/tty47", 10) == 0)
8910                     {
8911 {
8912 return dev_storage + 797;
8913
8914 }
8915                     }
8916                   else
8917                     {
8918 {
8919 return  NULL;
8920
8921 }
8922                     }
8923                 case 'n':
8924                   if (strncmp (KR_keyword, "/dev/nst47", 10) == 0)
8925                     {
8926 {
8927 return dev_storage + 87;
8928
8929 }
8930                     }
8931                   else
8932                     {
8933 {
8934 return  NULL;
8935
8936 }
8937                     }
8938                 default:
8939 {
8940 return  NULL;
8941
8942 }
8943                 }
8944             case '3':
8945               switch (KR_keyword [5])
8946                 {
8947                 case 't':
8948                   if (strncmp (KR_keyword, "/dev/tty37", 10) == 0)
8949                     {
8950 {
8951 return dev_storage + 787;
8952
8953 }
8954                     }
8955                   else
8956                     {
8957 {
8958 return  NULL;
8959
8960 }
8961                     }
8962                 case 'n':
8963                   if (strncmp (KR_keyword, "/dev/nst37", 10) == 0)
8964                     {
8965 {
8966 return dev_storage + 77;
8967
8968 }
8969                     }
8970                   else
8971                     {
8972 {
8973 return  NULL;
8974
8975 }
8976                     }
8977                 default:
8978 {
8979 return  NULL;
8980
8981 }
8982                 }
8983             case '2':
8984               switch (KR_keyword [5])
8985                 {
8986                 case 't':
8987                   if (strncmp (KR_keyword, "/dev/tty27", 10) == 0)
8988                     {
8989 {
8990 return dev_storage + 777;
8991
8992 }
8993                     }
8994                   else
8995                     {
8996 {
8997 return  NULL;
8998
8999 }
9000                     }
9001                 case 's':
9002                   if (strncmp (KR_keyword, "/dev/st127", 10) == 0)
9003                     {
9004 {
9005 return dev_storage + 748;
9006
9007 }
9008                     }
9009                   else
9010                     {
9011 {
9012 return  NULL;
9013
9014 }
9015                     }
9016                 case 'n':
9017                   if (strncmp (KR_keyword, "/dev/nst27", 10) == 0)
9018                     {
9019 {
9020 return dev_storage + 67;
9021
9022 }
9023                     }
9024                   else
9025                     {
9026 {
9027 return  NULL;
9028
9029 }
9030                     }
9031                 default:
9032 {
9033 return  NULL;
9034
9035 }
9036                 }
9037             case '1':
9038               switch (KR_keyword [5])
9039                 {
9040                 case 't':
9041                   if (strncmp (KR_keyword, "/dev/tty17", 10) == 0)
9042                     {
9043 {
9044 return dev_storage + 767;
9045
9046 }
9047                     }
9048                   else
9049                     {
9050 {
9051 return  NULL;
9052
9053 }
9054                     }
9055                 case 's':
9056                   if (strncmp (KR_keyword, "/dev/st117", 10) == 0)
9057                     {
9058 {
9059 return dev_storage + 738;
9060
9061 }
9062                     }
9063                   else
9064                     {
9065 {
9066 return  NULL;
9067
9068 }
9069                     }
9070                 case 'n':
9071                   if (strncmp (KR_keyword, "/dev/nst17", 10) == 0)
9072                     {
9073 {
9074 return dev_storage + 57;
9075
9076 }
9077                     }
9078                   else
9079                     {
9080 {
9081 return  NULL;
9082
9083 }
9084                     }
9085                 default:
9086 {
9087 return  NULL;
9088
9089 }
9090                 }
9091             case '0':
9092               if (strncmp (KR_keyword, "/dev/st107", 10) == 0)
9093                 {
9094 {
9095 return dev_storage + 728;
9096
9097 }
9098                 }
9099               else
9100                 {
9101 {
9102 return  NULL;
9103
9104 }
9105                 }
9106             default:
9107 {
9108 return  NULL;
9109
9110 }
9111             }
9112         case '6':
9113           switch (KR_keyword [8])
9114             {
9115             case 'S':
9116               if (strncmp (KR_keyword, "/dev/ttyS6", 10) == 0)
9117                 {
9118 {
9119 return dev_storage + 820;
9120
9121 }
9122                 }
9123               else
9124                 {
9125 {
9126 return  NULL;
9127
9128 }
9129                 }
9130             case '9':
9131               if (strncmp (KR_keyword, "/dev/nst96", 10) == 0)
9132                 {
9133 {
9134 return dev_storage + 136;
9135
9136 }
9137                 }
9138               else
9139                 {
9140 {
9141 return  NULL;
9142
9143 }
9144                 }
9145             case '8':
9146               if (strncmp (KR_keyword, "/dev/nst86", 10) == 0)
9147                 {
9148 {
9149 return dev_storage + 126;
9150
9151 }
9152                 }
9153               else
9154                 {
9155 {
9156 return  NULL;
9157
9158 }
9159                 }
9160             case '7':
9161               if (strncmp (KR_keyword, "/dev/nst76", 10) == 0)
9162                 {
9163 {
9164 return dev_storage + 116;
9165
9166 }
9167                 }
9168               else
9169                 {
9170 {
9171 return  NULL;
9172
9173 }
9174                 }
9175             case '6':
9176               if (strncmp (KR_keyword, "/dev/nst66", 10) == 0)
9177                 {
9178 {
9179 return dev_storage + 106;
9180
9181 }
9182                 }
9183               else
9184                 {
9185 {
9186 return  NULL;
9187
9188 }
9189                 }
9190             case '5':
9191               switch (KR_keyword [5])
9192                 {
9193                 case 't':
9194                   if (strncmp (KR_keyword, "/dev/tty56", 10) == 0)
9195                     {
9196 {
9197 return dev_storage + 806;
9198
9199 }
9200                     }
9201                   else
9202                     {
9203 {
9204 return  NULL;
9205
9206 }
9207                     }
9208                 case 'n':
9209                   if (strncmp (KR_keyword, "/dev/nst56", 10) == 0)
9210                     {
9211 {
9212 return dev_storage + 96;
9213
9214 }
9215                     }
9216                   else
9217                     {
9218 {
9219 return  NULL;
9220
9221 }
9222                     }
9223                 default:
9224 {
9225 return  NULL;
9226
9227 }
9228                 }
9229             case '4':
9230               switch (KR_keyword [5])
9231                 {
9232                 case 't':
9233                   if (strncmp (KR_keyword, "/dev/tty46", 10) == 0)
9234                     {
9235 {
9236 return dev_storage + 796;
9237
9238 }
9239                     }
9240                   else
9241                     {
9242 {
9243 return  NULL;
9244
9245 }
9246                     }
9247                 case 'n':
9248                   if (strncmp (KR_keyword, "/dev/nst46", 10) == 0)
9249                     {
9250 {
9251 return dev_storage + 86;
9252
9253 }
9254                     }
9255                   else
9256                     {
9257 {
9258 return  NULL;
9259
9260 }
9261                     }
9262                 default:
9263 {
9264 return  NULL;
9265
9266 }
9267                 }
9268             case '3':
9269               switch (KR_keyword [5])
9270                 {
9271                 case 't':
9272                   if (strncmp (KR_keyword, "/dev/tty36", 10) == 0)
9273                     {
9274 {
9275 return dev_storage + 786;
9276
9277 }
9278                     }
9279                   else
9280                     {
9281 {
9282 return  NULL;
9283
9284 }
9285                     }
9286                 case 'n':
9287                   if (strncmp (KR_keyword, "/dev/nst36", 10) == 0)
9288                     {
9289 {
9290 return dev_storage + 76;
9291
9292 }
9293                     }
9294                   else
9295                     {
9296 {
9297 return  NULL;
9298
9299 }
9300                     }
9301                 default:
9302 {
9303 return  NULL;
9304
9305 }
9306                 }
9307             case '2':
9308               switch (KR_keyword [5])
9309                 {
9310                 case 't':
9311                   if (strncmp (KR_keyword, "/dev/tty26", 10) == 0)
9312                     {
9313 {
9314 return dev_storage + 776;
9315
9316 }
9317                     }
9318                   else
9319                     {
9320 {
9321 return  NULL;
9322
9323 }
9324                     }
9325                 case 's':
9326                   if (strncmp (KR_keyword, "/dev/st126", 10) == 0)
9327                     {
9328 {
9329 return dev_storage + 747;
9330
9331 }
9332                     }
9333                   else
9334                     {
9335 {
9336 return  NULL;
9337
9338 }
9339                     }
9340                 case 'n':
9341                   if (strncmp (KR_keyword, "/dev/nst26", 10) == 0)
9342                     {
9343 {
9344 return dev_storage + 66;
9345
9346 }
9347                     }
9348                   else
9349                     {
9350 {
9351 return  NULL;
9352
9353 }
9354                     }
9355                 default:
9356 {
9357 return  NULL;
9358
9359 }
9360                 }
9361             case '1':
9362               switch (KR_keyword [5])
9363                 {
9364                 case 't':
9365                   if (strncmp (KR_keyword, "/dev/tty16", 10) == 0)
9366                     {
9367 {
9368 return dev_storage + 766;
9369
9370 }
9371                     }
9372                   else
9373                     {
9374 {
9375 return  NULL;
9376
9377 }
9378                     }
9379                 case 's':
9380                   if (strncmp (KR_keyword, "/dev/st116", 10) == 0)
9381                     {
9382 {
9383 return dev_storage + 737;
9384
9385 }
9386                     }
9387                   else
9388                     {
9389 {
9390 return  NULL;
9391
9392 }
9393                     }
9394                 case 'n':
9395                   if (strncmp (KR_keyword, "/dev/nst16", 10) == 0)
9396                     {
9397 {
9398 return dev_storage + 56;
9399
9400 }
9401                     }
9402                   else
9403                     {
9404 {
9405 return  NULL;
9406
9407 }
9408                     }
9409                 case 'c':
9410                   if (strncmp (KR_keyword, "/dev/com16", 10) == 0)
9411                     {
9412 {
9413 return dev_storage + 16;
9414
9415 }
9416                     }
9417                   else
9418                     {
9419 {
9420 return  NULL;
9421
9422 }
9423                     }
9424                 default:
9425 {
9426 return  NULL;
9427
9428 }
9429                 }
9430             case '0':
9431               if (strncmp (KR_keyword, "/dev/st106", 10) == 0)
9432                 {
9433 {
9434 return dev_storage + 727;
9435
9436 }
9437                 }
9438               else
9439                 {
9440 {
9441 return  NULL;
9442
9443 }
9444                 }
9445             default:
9446 {
9447 return  NULL;
9448
9449 }
9450             }
9451         case '5':
9452           switch (KR_keyword [7])
9453             {
9454             case 'z':
9455               if (strncmp (KR_keyword, "/dev/sdz15", 10) == 0)
9456                 {
9457 {
9458 return dev_storage + 604;
9459
9460 }
9461                 }
9462               else
9463                 {
9464 {
9465 return  NULL;
9466
9467 }
9468                 }
9469             case 'y':
9470               switch (KR_keyword [8])
9471                 {
9472                 case 'S':
9473                   if (strncmp (KR_keyword, "/dev/ttyS5", 10) == 0)
9474                     {
9475 {
9476 return dev_storage + 819;
9477
9478 }
9479                     }
9480                   else
9481                     {
9482 {
9483 return  NULL;
9484
9485 }
9486                     }
9487                 case '5':
9488                   if (strncmp (KR_keyword, "/dev/tty55", 10) == 0)
9489                     {
9490 {
9491 return dev_storage + 805;
9492
9493 }
9494                     }
9495                   else
9496                     {
9497 {
9498 return  NULL;
9499
9500 }
9501                     }
9502                 case '4':
9503                   if (strncmp (KR_keyword, "/dev/tty45", 10) == 0)
9504                     {
9505 {
9506 return dev_storage + 795;
9507
9508 }
9509                     }
9510                   else
9511                     {
9512 {
9513 return  NULL;
9514
9515 }
9516                     }
9517                 case '3':
9518                   if (strncmp (KR_keyword, "/dev/tty35", 10) == 0)
9519                     {
9520 {
9521 return dev_storage + 785;
9522
9523 }
9524                     }
9525                   else
9526                     {
9527 {
9528 return  NULL;
9529
9530 }
9531                     }
9532                 case '2':
9533                   if (strncmp (KR_keyword, "/dev/tty25", 10) == 0)
9534                     {
9535 {
9536 return dev_storage + 775;
9537
9538 }
9539                     }
9540                   else
9541                     {
9542 {
9543 return  NULL;
9544
9545 }
9546                     }
9547                 case '1':
9548                   switch (KR_keyword [5])
9549                     {
9550                     case 't':
9551                       if (strncmp (KR_keyword, "/dev/tty15", 10) == 0)
9552                         {
9553 {
9554 return dev_storage + 765;
9555
9556 }
9557                         }
9558                       else
9559                         {
9560 {
9561 return  NULL;
9562
9563 }
9564                         }
9565                     case 's':
9566                       if (strncmp (KR_keyword, "/dev/sdy15", 10) == 0)
9567                         {
9568 {
9569 return dev_storage + 589;
9570
9571 }
9572                         }
9573                       else
9574                         {
9575 {
9576 return  NULL;
9577
9578 }
9579                         }
9580                     default:
9581 {
9582 return  NULL;
9583
9584 }
9585                     }
9586                 default:
9587 {
9588 return  NULL;
9589
9590 }
9591                 }
9592             case 'x':
9593               if (strncmp (KR_keyword, "/dev/sdx15", 10) == 0)
9594                 {
9595 {
9596 return dev_storage + 574;
9597
9598 }
9599                 }
9600               else
9601                 {
9602 {
9603 return  NULL;
9604
9605 }
9606                 }
9607             case 'w':
9608               if (strncmp (KR_keyword, "/dev/sdw15", 10) == 0)
9609                 {
9610 {
9611 return dev_storage + 559;
9612
9613 }
9614                 }
9615               else
9616                 {
9617 {
9618 return  NULL;
9619
9620 }
9621                 }
9622             case 'v':
9623               if (strncmp (KR_keyword, "/dev/sdv15", 10) == 0)
9624                 {
9625 {
9626 return dev_storage + 544;
9627
9628 }
9629                 }
9630               else
9631                 {
9632 {
9633 return  NULL;
9634
9635 }
9636                 }
9637             case 'u':
9638               if (strncmp (KR_keyword, "/dev/sdu15", 10) == 0)
9639                 {
9640 {
9641 return dev_storage + 529;
9642
9643 }
9644                 }
9645               else
9646                 {
9647 {
9648 return  NULL;
9649
9650 }
9651                 }
9652             case 't':
9653               switch (KR_keyword [8])
9654                 {
9655                 case '9':
9656                   if (strncmp (KR_keyword, "/dev/nst95", 10) == 0)
9657                     {
9658 {
9659 return dev_storage + 135;
9660
9661 }
9662                     }
9663                   else
9664                     {
9665 {
9666 return  NULL;
9667
9668 }
9669                     }
9670                 case '8':
9671                   if (strncmp (KR_keyword, "/dev/nst85", 10) == 0)
9672                     {
9673 {
9674 return dev_storage + 125;
9675
9676 }
9677                     }
9678                   else
9679                     {
9680 {
9681 return  NULL;
9682
9683 }
9684                     }
9685                 case '7':
9686                   if (strncmp (KR_keyword, "/dev/nst75", 10) == 0)
9687                     {
9688 {
9689 return dev_storage + 115;
9690
9691 }
9692                     }
9693                   else
9694                     {
9695 {
9696 return  NULL;
9697
9698 }
9699                     }
9700                 case '6':
9701                   if (strncmp (KR_keyword, "/dev/nst65", 10) == 0)
9702                     {
9703 {
9704 return dev_storage + 105;
9705
9706 }
9707                     }
9708                   else
9709                     {
9710 {
9711 return  NULL;
9712
9713 }
9714                     }
9715                 case '5':
9716                   if (strncmp (KR_keyword, "/dev/nst55", 10) == 0)
9717                     {
9718 {
9719 return dev_storage + 95;
9720
9721 }
9722                     }
9723                   else
9724                     {
9725 {
9726 return  NULL;
9727
9728 }
9729                     }
9730                 case '4':
9731                   if (strncmp (KR_keyword, "/dev/nst45", 10) == 0)
9732                     {
9733 {
9734 return dev_storage + 85;
9735
9736 }
9737                     }
9738                   else
9739                     {
9740 {
9741 return  NULL;
9742
9743 }
9744                     }
9745                 case '3':
9746                   if (strncmp (KR_keyword, "/dev/nst35", 10) == 0)
9747                     {
9748 {
9749 return dev_storage + 75;
9750
9751 }
9752                     }
9753                   else
9754                     {
9755 {
9756 return  NULL;
9757
9758 }
9759                     }
9760                 case '2':
9761                   if (strncmp (KR_keyword, "/dev/nst25", 10) == 0)
9762                     {
9763 {
9764 return dev_storage + 65;
9765
9766 }
9767                     }
9768                   else
9769                     {
9770 {
9771 return  NULL;
9772
9773 }
9774                     }
9775                 case '1':
9776                   switch (KR_keyword [5])
9777                     {
9778                     case 's':
9779                       if (strncmp (KR_keyword, "/dev/sdt15", 10) == 0)
9780                         {
9781 {
9782 return dev_storage + 514;
9783
9784 }
9785                         }
9786                       else
9787                         {
9788 {
9789 return  NULL;
9790
9791 }
9792                         }
9793                     case 'n':
9794                       if (strncmp (KR_keyword, "/dev/nst15", 10) == 0)
9795                         {
9796 {
9797 return dev_storage + 55;
9798
9799 }
9800                         }
9801                       else
9802                         {
9803 {
9804 return  NULL;
9805
9806 }
9807                         }
9808                     default:
9809 {
9810 return  NULL;
9811
9812 }
9813                     }
9814                 default:
9815 {
9816 return  NULL;
9817
9818 }
9819                 }
9820             case 's':
9821               if (strncmp (KR_keyword, "/dev/sds15", 10) == 0)
9822                 {
9823 {
9824 return dev_storage + 499;
9825
9826 }
9827                 }
9828               else
9829                 {
9830 {
9831 return  NULL;
9832
9833 }
9834                 }
9835             case 'r':
9836               if (strncmp (KR_keyword, "/dev/sdr15", 10) == 0)
9837                 {
9838 {
9839 return dev_storage + 484;
9840
9841 }
9842                 }
9843               else
9844                 {
9845 {
9846 return  NULL;
9847
9848 }
9849                 }
9850             case 'q':
9851               if (strncmp (KR_keyword, "/dev/sdq15", 10) == 0)
9852                 {
9853 {
9854 return dev_storage + 469;
9855
9856 }
9857                 }
9858               else
9859                 {
9860 {
9861 return  NULL;
9862
9863 }
9864                 }
9865             case 'p':
9866               if (strncmp (KR_keyword, "/dev/sdp15", 10) == 0)
9867                 {
9868 {
9869 return dev_storage + 454;
9870
9871 }
9872                 }
9873               else
9874                 {
9875 {
9876 return  NULL;
9877
9878 }
9879                 }
9880             case 'o':
9881               if (strncmp (KR_keyword, "/dev/sdo15", 10) == 0)
9882                 {
9883 {
9884 return dev_storage + 439;
9885
9886 }
9887                 }
9888               else
9889                 {
9890 {
9891 return  NULL;
9892
9893 }
9894                 }
9895             case 'n':
9896               if (strncmp (KR_keyword, "/dev/sdn15", 10) == 0)
9897                 {
9898 {
9899 return dev_storage + 424;
9900
9901 }
9902                 }
9903               else
9904                 {
9905 {
9906 return  NULL;
9907
9908 }
9909                 }
9910             case 'm':
9911               switch (KR_keyword [5])
9912                 {
9913                 case 's':
9914                   if (strncmp (KR_keyword, "/dev/sdm15", 10) == 0)
9915                     {
9916 {
9917 return dev_storage + 409;
9918
9919 }
9920                     }
9921                   else
9922                     {
9923 {
9924 return  NULL;
9925
9926 }
9927                     }
9928                 case 'c':
9929                   if (strncmp (KR_keyword, "/dev/com15", 10) == 0)
9930                     {
9931 {
9932 return dev_storage + 15;
9933
9934 }
9935                     }
9936                   else
9937                     {
9938 {
9939 return  NULL;
9940
9941 }
9942                     }
9943                 default:
9944 {
9945 return  NULL;
9946
9947 }
9948                 }
9949             case 'l':
9950               if (strncmp (KR_keyword, "/dev/sdl15", 10) == 0)
9951                 {
9952 {
9953 return dev_storage + 394;
9954
9955 }
9956                 }
9957               else
9958                 {
9959 {
9960 return  NULL;
9961
9962 }
9963                 }
9964             case 'k':
9965               if (strncmp (KR_keyword, "/dev/sdk15", 10) == 0)
9966                 {
9967 {
9968 return dev_storage + 379;
9969
9970 }
9971                 }
9972               else
9973                 {
9974 {
9975 return  NULL;
9976
9977 }
9978                 }
9979             case 'j':
9980               if (strncmp (KR_keyword, "/dev/sdj15", 10) == 0)
9981                 {
9982 {
9983 return dev_storage + 364;
9984
9985 }
9986                 }
9987               else
9988                 {
9989 {
9990 return  NULL;
9991
9992 }
9993                 }
9994             case 'i':
9995               if (strncmp (KR_keyword, "/dev/sdi15", 10) == 0)
9996                 {
9997 {
9998 return dev_storage + 349;
9999
10000 }
10001                 }
10002               else
10003                 {
10004 {
10005 return  NULL;
10006
10007 }
10008                 }
10009             case 'h':
10010               if (strncmp (KR_keyword, "/dev/sdh15", 10) == 0)
10011                 {
10012 {
10013 return dev_storage + 334;
10014
10015 }
10016                 }
10017               else
10018                 {
10019 {
10020 return  NULL;
10021
10022 }
10023                 }
10024             case 'g':
10025               if (strncmp (KR_keyword, "/dev/sdg15", 10) == 0)
10026                 {
10027 {
10028 return dev_storage + 319;
10029
10030 }
10031                 }
10032               else
10033                 {
10034 {
10035 return  NULL;
10036
10037 }
10038                 }
10039             case 'f':
10040               if (strncmp (KR_keyword, "/dev/sdf15", 10) == 0)
10041                 {
10042 {
10043 return dev_storage + 304;
10044
10045 }
10046                 }
10047               else
10048                 {
10049 {
10050 return  NULL;
10051
10052 }
10053                 }
10054             case 'e':
10055               if (strncmp (KR_keyword, "/dev/sde15", 10) == 0)
10056                 {
10057 {
10058 return dev_storage + 289;
10059
10060 }
10061                 }
10062               else
10063                 {
10064 {
10065 return  NULL;
10066
10067 }
10068                 }
10069             case 'd':
10070               switch (KR_keyword [6])
10071                 {
10072                 case 'd':
10073                   if (strncmp (KR_keyword, "/dev/sdd15", 10) == 0)
10074                     {
10075 {
10076 return dev_storage + 274;
10077
10078 }
10079                     }
10080                   else
10081                     {
10082 {
10083 return  NULL;
10084
10085 }
10086                     }
10087                 case 'c':
10088                   if (strncmp (KR_keyword, "/dev/scd15", 10) == 0)
10089                     {
10090 {
10091 return dev_storage + 188;
10092
10093 }
10094                     }
10095                   else
10096                     {
10097 {
10098 return  NULL;
10099
10100 }
10101                     }
10102                 default:
10103 {
10104 return  NULL;
10105
10106 }
10107                 }
10108             case 'c':
10109               if (strncmp (KR_keyword, "/dev/sdc15", 10) == 0)
10110                 {
10111 {
10112 return dev_storage + 259;
10113
10114 }
10115                 }
10116               else
10117                 {
10118 {
10119 return  NULL;
10120
10121 }
10122                 }
10123             case 'b':
10124               if (strncmp (KR_keyword, "/dev/sdb15", 10) == 0)
10125                 {
10126 {
10127 return dev_storage + 244;
10128
10129 }
10130                 }
10131               else
10132                 {
10133 {
10134 return  NULL;
10135
10136 }
10137                 }
10138             case 'a':
10139               if (strncmp (KR_keyword, "/dev/sda15", 10) == 0)
10140                 {
10141 {
10142 return dev_storage + 229;
10143
10144 }
10145                 }
10146               else
10147                 {
10148 {
10149 return  NULL;
10150
10151 }
10152                 }
10153             case '1':
10154               switch (KR_keyword [8])
10155                 {
10156                 case '2':
10157                   if (strncmp (KR_keyword, "/dev/st125", 10) == 0)
10158                     {
10159 {
10160 return dev_storage + 746;
10161
10162 }
10163                     }
10164                   else
10165                     {
10166 {
10167 return  NULL;
10168
10169 }
10170                     }
10171                 case '1':
10172                   if (strncmp (KR_keyword, "/dev/st115", 10) == 0)
10173                     {
10174 {
10175 return dev_storage + 736;
10176
10177 }
10178                     }
10179                   else
10180                     {
10181 {
10182 return  NULL;
10183
10184 }
10185                     }
10186                 case '0':
10187                   if (strncmp (KR_keyword, "/dev/st105", 10) == 0)
10188                     {
10189 {
10190 return dev_storage + 726;
10191
10192 }
10193                     }
10194                   else
10195                     {
10196 {
10197 return  NULL;
10198
10199 }
10200                     }
10201                 default:
10202 {
10203 return  NULL;
10204
10205 }
10206                 }
10207             default:
10208 {
10209 return  NULL;
10210
10211 }
10212             }
10213         case '4':
10214           switch (KR_keyword [7])
10215             {
10216             case 'z':
10217               if (strncmp (KR_keyword, "/dev/sdz14", 10) == 0)
10218                 {
10219 {
10220 return dev_storage + 603;
10221
10222 }
10223                 }
10224               else
10225                 {
10226 {
10227 return  NULL;
10228
10229 }
10230                 }
10231             case 'y':
10232               switch (KR_keyword [8])
10233                 {
10234                 case 'S':
10235                   if (strncmp (KR_keyword, "/dev/ttyS4", 10) == 0)
10236                     {
10237 {
10238 return dev_storage + 818;
10239
10240 }
10241                     }
10242                   else
10243                     {
10244 {
10245 return  NULL;
10246
10247 }
10248                     }
10249                 case '5':
10250                   if (strncmp (KR_keyword, "/dev/tty54", 10) == 0)
10251                     {
10252 {
10253 return dev_storage + 804;
10254
10255 }
10256                     }
10257                   else
10258                     {
10259 {
10260 return  NULL;
10261
10262 }
10263                     }
10264                 case '4':
10265                   if (strncmp (KR_keyword, "/dev/tty44", 10) == 0)
10266                     {
10267 {
10268 return dev_storage + 794;
10269
10270 }
10271                     }
10272                   else
10273                     {
10274 {
10275 return  NULL;
10276
10277 }
10278                     }
10279                 case '3':
10280                   if (strncmp (KR_keyword, "/dev/tty34", 10) == 0)
10281                     {
10282 {
10283 return dev_storage + 784;
10284
10285 }
10286                     }
10287                   else
10288                     {
10289 {
10290 return  NULL;
10291
10292 }
10293                     }
10294                 case '2':
10295                   if (strncmp (KR_keyword, "/dev/tty24", 10) == 0)
10296                     {
10297 {
10298 return dev_storage + 774;
10299
10300 }
10301                     }
10302                   else
10303                     {
10304 {
10305 return  NULL;
10306
10307 }
10308                     }
10309                 case '1':
10310                   switch (KR_keyword [5])
10311                     {
10312                     case 't':
10313                       if (strncmp (KR_keyword, "/dev/tty14", 10) == 0)
10314                         {
10315 {
10316 return dev_storage + 764;
10317
10318 }
10319                         }
10320                       else
10321                         {
10322 {
10323 return  NULL;
10324
10325 }
10326                         }
10327                     case 's':
10328                       if (strncmp (KR_keyword, "/dev/sdy14", 10) == 0)
10329                         {
10330 {
10331 return dev_storage + 588;
10332
10333 }
10334                         }
10335                       else
10336                         {
10337 {
10338 return  NULL;
10339
10340 }
10341                         }
10342                     default:
10343 {
10344 return  NULL;
10345
10346 }
10347                     }
10348                 default:
10349 {
10350 return  NULL;
10351
10352 }
10353                 }
10354             case 'x':
10355               if (strncmp (KR_keyword, "/dev/sdx14", 10) == 0)
10356                 {
10357 {
10358 return dev_storage + 573;
10359
10360 }
10361                 }
10362               else
10363                 {
10364 {
10365 return  NULL;
10366
10367 }
10368                 }
10369             case 'w':
10370               if (strncmp (KR_keyword, "/dev/sdw14", 10) == 0)
10371                 {
10372 {
10373 return dev_storage + 558;
10374
10375 }
10376                 }
10377               else
10378                 {
10379 {
10380 return  NULL;
10381
10382 }
10383                 }
10384             case 'v':
10385               if (strncmp (KR_keyword, "/dev/sdv14", 10) == 0)
10386                 {
10387 {
10388 return dev_storage + 543;
10389
10390 }
10391                 }
10392               else
10393                 {
10394 {
10395 return  NULL;
10396
10397 }
10398                 }
10399             case 'u':
10400               if (strncmp (KR_keyword, "/dev/sdu14", 10) == 0)
10401                 {
10402 {
10403 return dev_storage + 528;
10404
10405 }
10406                 }
10407               else
10408                 {
10409 {
10410 return  NULL;
10411
10412 }
10413                 }
10414             case 't':
10415               switch (KR_keyword [8])
10416                 {
10417                 case '9':
10418                   if (strncmp (KR_keyword, "/dev/nst94", 10) == 0)
10419                     {
10420 {
10421 return dev_storage + 134;
10422
10423 }
10424                     }
10425                   else
10426                     {
10427 {
10428 return  NULL;
10429
10430 }
10431                     }
10432                 case '8':
10433                   if (strncmp (KR_keyword, "/dev/nst84", 10) == 0)
10434                     {
10435 {
10436 return dev_storage + 124;
10437
10438 }
10439                     }
10440                   else
10441                     {
10442 {
10443 return  NULL;
10444
10445 }
10446                     }
10447                 case '7':
10448                   if (strncmp (KR_keyword, "/dev/nst74", 10) == 0)
10449                     {
10450 {
10451 return dev_storage + 114;
10452
10453 }
10454                     }
10455                   else
10456                     {
10457 {
10458 return  NULL;
10459
10460 }
10461                     }
10462                 case '6':
10463                   if (strncmp (KR_keyword, "/dev/nst64", 10) == 0)
10464                     {
10465 {
10466 return dev_storage + 104;
10467
10468 }
10469                     }
10470                   else
10471                     {
10472 {
10473 return  NULL;
10474
10475 }
10476                     }
10477                 case '5':
10478                   if (strncmp (KR_keyword, "/dev/nst54", 10) == 0)
10479                     {
10480 {
10481 return dev_storage + 94;
10482
10483 }
10484                     }
10485                   else
10486                     {
10487 {
10488 return  NULL;
10489
10490 }
10491                     }
10492                 case '4':
10493                   if (strncmp (KR_keyword, "/dev/nst44", 10) == 0)
10494                     {
10495 {
10496 return dev_storage + 84;
10497
10498 }
10499                     }
10500                   else
10501                     {
10502 {
10503 return  NULL;
10504
10505 }
10506                     }
10507                 case '3':
10508                   if (strncmp (KR_keyword, "/dev/nst34", 10) == 0)
10509                     {
10510 {
10511 return dev_storage + 74;
10512
10513 }
10514                     }
10515                   else
10516                     {
10517 {
10518 return  NULL;
10519
10520 }
10521                     }
10522                 case '2':
10523                   if (strncmp (KR_keyword, "/dev/nst24", 10) == 0)
10524                     {
10525 {
10526 return dev_storage + 64;
10527
10528 }
10529                     }
10530                   else
10531                     {
10532 {
10533 return  NULL;
10534
10535 }
10536                     }
10537                 case '1':
10538                   switch (KR_keyword [5])
10539                     {
10540                     case 's':
10541                       if (strncmp (KR_keyword, "/dev/sdt14", 10) == 0)
10542                         {
10543 {
10544 return dev_storage + 513;
10545
10546 }
10547                         }
10548                       else
10549                         {
10550 {
10551 return  NULL;
10552
10553 }
10554                         }
10555                     case 'n':
10556                       if (strncmp (KR_keyword, "/dev/nst14", 10) == 0)
10557                         {
10558 {
10559 return dev_storage + 54;
10560
10561 }
10562                         }
10563                       else
10564                         {
10565 {
10566 return  NULL;
10567
10568 }
10569                         }
10570                     default:
10571 {
10572 return  NULL;
10573
10574 }
10575                     }
10576                 default:
10577 {
10578 return  NULL;
10579
10580 }
10581                 }
10582             case 's':
10583               if (strncmp (KR_keyword, "/dev/sds14", 10) == 0)
10584                 {
10585 {
10586 return dev_storage + 498;
10587
10588 }
10589                 }
10590               else
10591                 {
10592 {
10593 return  NULL;
10594
10595 }
10596                 }
10597             case 'r':
10598               if (strncmp (KR_keyword, "/dev/sdr14", 10) == 0)
10599                 {
10600 {
10601 return dev_storage + 483;
10602
10603 }
10604                 }
10605               else
10606                 {
10607 {
10608 return  NULL;
10609
10610 }
10611                 }
10612             case 'q':
10613               if (strncmp (KR_keyword, "/dev/sdq14", 10) == 0)
10614                 {
10615 {
10616 return dev_storage + 468;
10617
10618 }
10619                 }
10620               else
10621                 {
10622 {
10623 return  NULL;
10624
10625 }
10626                 }
10627             case 'p':
10628               if (strncmp (KR_keyword, "/dev/sdp14", 10) == 0)
10629                 {
10630 {
10631 return dev_storage + 453;
10632
10633 }
10634                 }
10635               else
10636                 {
10637 {
10638 return  NULL;
10639
10640 }
10641                 }
10642             case 'o':
10643               if (strncmp (KR_keyword, "/dev/sdo14", 10) == 0)
10644                 {
10645 {
10646 return dev_storage + 438;
10647
10648 }
10649                 }
10650               else
10651                 {
10652 {
10653 return  NULL;
10654
10655 }
10656                 }
10657             case 'n':
10658               if (strncmp (KR_keyword, "/dev/sdn14", 10) == 0)
10659                 {
10660 {
10661 return dev_storage + 423;
10662
10663 }
10664                 }
10665               else
10666                 {
10667 {
10668 return  NULL;
10669
10670 }
10671                 }
10672             case 'm':
10673               switch (KR_keyword [5])
10674                 {
10675                 case 's':
10676                   if (strncmp (KR_keyword, "/dev/sdm14", 10) == 0)
10677                     {
10678 {
10679 return dev_storage + 408;
10680
10681 }
10682                     }
10683                   else
10684                     {
10685 {
10686 return  NULL;
10687
10688 }
10689                     }
10690                 case 'c':
10691                   if (strncmp (KR_keyword, "/dev/com14", 10) == 0)
10692                     {
10693 {
10694 return dev_storage + 14;
10695
10696 }
10697                     }
10698                   else
10699                     {
10700 {
10701 return  NULL;
10702
10703 }
10704                     }
10705                 default:
10706 {
10707 return  NULL;
10708
10709 }
10710                 }
10711             case 'l':
10712               if (strncmp (KR_keyword, "/dev/sdl14", 10) == 0)
10713                 {
10714 {
10715 return dev_storage + 393;
10716
10717 }
10718                 }
10719               else
10720                 {
10721 {
10722 return  NULL;
10723
10724 }
10725                 }
10726             case 'k':
10727               if (strncmp (KR_keyword, "/dev/sdk14", 10) == 0)
10728                 {
10729 {
10730 return dev_storage + 378;
10731
10732 }
10733                 }
10734               else
10735                 {
10736 {
10737 return  NULL;
10738
10739 }
10740                 }
10741             case 'j':
10742               if (strncmp (KR_keyword, "/dev/sdj14", 10) == 0)
10743                 {
10744 {
10745 return dev_storage + 363;
10746
10747 }
10748                 }
10749               else
10750                 {
10751 {
10752 return  NULL;
10753
10754 }
10755                 }
10756             case 'i':
10757               if (strncmp (KR_keyword, "/dev/sdi14", 10) == 0)
10758                 {
10759 {
10760 return dev_storage + 348;
10761
10762 }
10763                 }
10764               else
10765                 {
10766 {
10767 return  NULL;
10768
10769 }
10770                 }
10771             case 'h':
10772               if (strncmp (KR_keyword, "/dev/sdh14", 10) == 0)
10773                 {
10774 {
10775 return dev_storage + 333;
10776
10777 }
10778                 }
10779               else
10780                 {
10781 {
10782 return  NULL;
10783
10784 }
10785                 }
10786             case 'g':
10787               if (strncmp (KR_keyword, "/dev/sdg14", 10) == 0)
10788                 {
10789 {
10790 return dev_storage + 318;
10791
10792 }
10793                 }
10794               else
10795                 {
10796 {
10797 return  NULL;
10798
10799 }
10800                 }
10801             case 'f':
10802               if (strncmp (KR_keyword, "/dev/sdf14", 10) == 0)
10803                 {
10804 {
10805 return dev_storage + 303;
10806
10807 }
10808                 }
10809               else
10810                 {
10811 {
10812 return  NULL;
10813
10814 }
10815                 }
10816             case 'e':
10817               if (strncmp (KR_keyword, "/dev/sde14", 10) == 0)
10818                 {
10819 {
10820 return dev_storage + 288;
10821
10822 }
10823                 }
10824               else
10825                 {
10826 {
10827 return  NULL;
10828
10829 }
10830                 }
10831             case 'd':
10832               switch (KR_keyword [6])
10833                 {
10834                 case 'd':
10835                   if (strncmp (KR_keyword, "/dev/sdd14", 10) == 0)
10836                     {
10837 {
10838 return dev_storage + 273;
10839
10840 }
10841                     }
10842                   else
10843                     {
10844 {
10845 return  NULL;
10846
10847 }
10848                     }
10849                 case 'c':
10850                   if (strncmp (KR_keyword, "/dev/scd14", 10) == 0)
10851                     {
10852 {
10853 return dev_storage + 187;
10854
10855 }
10856                     }
10857                   else
10858                     {
10859 {
10860 return  NULL;
10861
10862 }
10863                     }
10864                 default:
10865 {
10866 return  NULL;
10867
10868 }
10869                 }
10870             case 'c':
10871               if (strncmp (KR_keyword, "/dev/sdc14", 10) == 0)
10872                 {
10873 {
10874 return dev_storage + 258;
10875
10876 }
10877                 }
10878               else
10879                 {
10880 {
10881 return  NULL;
10882
10883 }
10884                 }
10885             case 'b':
10886               if (strncmp (KR_keyword, "/dev/sdb14", 10) == 0)
10887                 {
10888 {
10889 return dev_storage + 243;
10890
10891 }
10892                 }
10893               else
10894                 {
10895 {
10896 return  NULL;
10897
10898 }
10899                 }
10900             case 'a':
10901               if (strncmp (KR_keyword, "/dev/sda14", 10) == 0)
10902                 {
10903 {
10904 return dev_storage + 228;
10905
10906 }
10907                 }
10908               else
10909                 {
10910 {
10911 return  NULL;
10912
10913 }
10914                 }
10915             case '1':
10916               switch (KR_keyword [8])
10917                 {
10918                 case '2':
10919                   if (strncmp (KR_keyword, "/dev/st124", 10) == 0)
10920                     {
10921 {
10922 return dev_storage + 745;
10923
10924 }
10925                     }
10926                   else
10927                     {
10928 {
10929 return  NULL;
10930
10931 }
10932                     }
10933                 case '1':
10934                   if (strncmp (KR_keyword, "/dev/st114", 10) == 0)
10935                     {
10936 {
10937 return dev_storage + 735;
10938
10939 }
10940                     }
10941                   else
10942                     {
10943 {
10944 return  NULL;
10945
10946 }
10947                     }
10948                 case '0':
10949                   if (strncmp (KR_keyword, "/dev/st104", 10) == 0)
10950                     {
10951 {
10952 return dev_storage + 725;
10953
10954 }
10955                     }
10956                   else
10957                     {
10958 {
10959 return  NULL;
10960
10961 }
10962                     }
10963                 default:
10964 {
10965 return  NULL;
10966
10967 }
10968                 }
10969             default:
10970 {
10971 return  NULL;
10972
10973 }
10974             }
10975         case '3':
10976           switch (KR_keyword [7])
10977             {
10978             case 'z':
10979               if (strncmp (KR_keyword, "/dev/sdz13", 10) == 0)
10980                 {
10981 {
10982 return dev_storage + 602;
10983
10984 }
10985                 }
10986               else
10987                 {
10988 {
10989 return  NULL;
10990
10991 }
10992                 }
10993             case 'y':
10994               switch (KR_keyword [8])
10995                 {
10996                 case 'S':
10997                   if (strncmp (KR_keyword, "/dev/ttyS3", 10) == 0)
10998                     {
10999 {
11000 return dev_storage + 817;
11001
11002 }
11003                     }
11004                   else
11005                     {
11006 {
11007 return  NULL;
11008
11009 }
11010                     }
11011                 case '6':
11012                   if (strncmp (KR_keyword, "/dev/tty63", 10) == 0)
11013                     {
11014 {
11015 return dev_storage + 813;
11016
11017 }
11018                     }
11019                   else
11020                     {
11021 {
11022 return  NULL;
11023
11024 }
11025                     }
11026                 case '5':
11027                   if (strncmp (KR_keyword, "/dev/tty53", 10) == 0)
11028                     {
11029 {
11030 return dev_storage + 803;
11031
11032 }
11033                     }
11034                   else
11035                     {
11036 {
11037 return  NULL;
11038
11039 }
11040                     }
11041                 case '4':
11042                   if (strncmp (KR_keyword, "/dev/tty43", 10) == 0)
11043                     {
11044 {
11045 return dev_storage + 793;
11046
11047 }
11048                     }
11049                   else
11050                     {
11051 {
11052 return  NULL;
11053
11054 }
11055                     }
11056                 case '3':
11057                   if (strncmp (KR_keyword, "/dev/tty33", 10) == 0)
11058                     {
11059 {
11060 return dev_storage + 783;
11061
11062 }
11063                     }
11064                   else
11065                     {
11066 {
11067 return  NULL;
11068
11069 }
11070                     }
11071                 case '2':
11072                   if (strncmp (KR_keyword, "/dev/tty23", 10) == 0)
11073                     {
11074 {
11075 return dev_storage + 773;
11076
11077 }
11078                     }
11079                   else
11080                     {
11081 {
11082 return  NULL;
11083
11084 }
11085                     }
11086                 case '1':
11087                   switch (KR_keyword [5])
11088                     {
11089                     case 't':
11090                       if (strncmp (KR_keyword, "/dev/tty13", 10) == 0)
11091                         {
11092 {
11093 return dev_storage + 763;
11094
11095 }
11096                         }
11097                       else
11098                         {
11099 {
11100 return  NULL;
11101
11102 }
11103                         }
11104                     case 's':
11105                       if (strncmp (KR_keyword, "/dev/sdy13", 10) == 0)
11106                         {
11107 {
11108 return dev_storage + 587;
11109
11110 }
11111                         }
11112                       else
11113                         {
11114 {
11115 return  NULL;
11116
11117 }
11118                         }
11119                     default:
11120 {
11121 return  NULL;
11122
11123 }
11124                     }
11125                 default:
11126 {
11127 return  NULL;
11128
11129 }
11130                 }
11131             case 'x':
11132               if (strncmp (KR_keyword, "/dev/sdx13", 10) == 0)
11133                 {
11134 {
11135 return dev_storage + 572;
11136
11137 }
11138                 }
11139               else
11140                 {
11141 {
11142 return  NULL;
11143
11144 }
11145                 }
11146             case 'w':
11147               if (strncmp (KR_keyword, "/dev/sdw13", 10) == 0)
11148                 {
11149 {
11150 return dev_storage + 557;
11151
11152 }
11153                 }
11154               else
11155                 {
11156 {
11157 return  NULL;
11158
11159 }
11160                 }
11161             case 'v':
11162               if (strncmp (KR_keyword, "/dev/sdv13", 10) == 0)
11163                 {
11164 {
11165 return dev_storage + 542;
11166
11167 }
11168                 }
11169               else
11170                 {
11171 {
11172 return  NULL;
11173
11174 }
11175                 }
11176             case 'u':
11177               if (strncmp (KR_keyword, "/dev/sdu13", 10) == 0)
11178                 {
11179 {
11180 return dev_storage + 527;
11181
11182 }
11183                 }
11184               else
11185                 {
11186 {
11187 return  NULL;
11188
11189 }
11190                 }
11191             case 't':
11192               switch (KR_keyword [8])
11193                 {
11194                 case '9':
11195                   if (strncmp (KR_keyword, "/dev/nst93", 10) == 0)
11196                     {
11197 {
11198 return dev_storage + 133;
11199
11200 }
11201                     }
11202                   else
11203                     {
11204 {
11205 return  NULL;
11206
11207 }
11208                     }
11209                 case '8':
11210                   if (strncmp (KR_keyword, "/dev/nst83", 10) == 0)
11211                     {
11212 {
11213 return dev_storage + 123;
11214
11215 }
11216                     }
11217                   else
11218                     {
11219 {
11220 return  NULL;
11221
11222 }
11223                     }
11224                 case '7':
11225                   if (strncmp (KR_keyword, "/dev/nst73", 10) == 0)
11226                     {
11227 {
11228 return dev_storage + 113;
11229
11230 }
11231                     }
11232                   else
11233                     {
11234 {
11235 return  NULL;
11236
11237 }
11238                     }
11239                 case '6':
11240                   if (strncmp (KR_keyword, "/dev/nst63", 10) == 0)
11241                     {
11242 {
11243 return dev_storage + 103;
11244
11245 }
11246                     }
11247                   else
11248                     {
11249 {
11250 return  NULL;
11251
11252 }
11253                     }
11254                 case '5':
11255                   if (strncmp (KR_keyword, "/dev/nst53", 10) == 0)
11256                     {
11257 {
11258 return dev_storage + 93;
11259
11260 }
11261                     }
11262                   else
11263                     {
11264 {
11265 return  NULL;
11266
11267 }
11268                     }
11269                 case '4':
11270                   if (strncmp (KR_keyword, "/dev/nst43", 10) == 0)
11271                     {
11272 {
11273 return dev_storage + 83;
11274
11275 }
11276                     }
11277                   else
11278                     {
11279 {
11280 return  NULL;
11281
11282 }
11283                     }
11284                 case '3':
11285                   if (strncmp (KR_keyword, "/dev/nst33", 10) == 0)
11286                     {
11287 {
11288 return dev_storage + 73;
11289
11290 }
11291                     }
11292                   else
11293                     {
11294 {
11295 return  NULL;
11296
11297 }
11298                     }
11299                 case '2':
11300                   if (strncmp (KR_keyword, "/dev/nst23", 10) == 0)
11301                     {
11302 {
11303 return dev_storage + 63;
11304
11305 }
11306                     }
11307                   else
11308                     {
11309 {
11310 return  NULL;
11311
11312 }
11313                     }
11314                 case '1':
11315                   switch (KR_keyword [5])
11316                     {
11317                     case 's':
11318                       if (strncmp (KR_keyword, "/dev/sdt13", 10) == 0)
11319                         {
11320 {
11321 return dev_storage + 512;
11322
11323 }
11324                         }
11325                       else
11326                         {
11327 {
11328 return  NULL;
11329
11330 }
11331                         }
11332                     case 'n':
11333                       if (strncmp (KR_keyword, "/dev/nst13", 10) == 0)
11334                         {
11335 {
11336 return dev_storage + 53;
11337
11338 }
11339                         }
11340                       else
11341                         {
11342 {
11343 return  NULL;
11344
11345 }
11346                         }
11347                     default:
11348 {
11349 return  NULL;
11350
11351 }
11352                     }
11353                 default:
11354 {
11355 return  NULL;
11356
11357 }
11358                 }
11359             case 's':
11360               if (strncmp (KR_keyword, "/dev/sds13", 10) == 0)
11361                 {
11362 {
11363 return dev_storage + 497;
11364
11365 }
11366                 }
11367               else
11368                 {
11369 {
11370 return  NULL;
11371
11372 }
11373                 }
11374             case 'r':
11375               if (strncmp (KR_keyword, "/dev/sdr13", 10) == 0)
11376                 {
11377 {
11378 return dev_storage + 482;
11379
11380 }
11381                 }
11382               else
11383                 {
11384 {
11385 return  NULL;
11386
11387 }
11388                 }
11389             case 'q':
11390               if (strncmp (KR_keyword, "/dev/sdq13", 10) == 0)
11391                 {
11392 {
11393 return dev_storage + 467;
11394
11395 }
11396                 }
11397               else
11398                 {
11399 {
11400 return  NULL;
11401
11402 }
11403                 }
11404             case 'p':
11405               if (strncmp (KR_keyword, "/dev/sdp13", 10) == 0)
11406                 {
11407 {
11408 return dev_storage + 452;
11409
11410 }
11411                 }
11412               else
11413                 {
11414 {
11415 return  NULL;
11416
11417 }
11418                 }
11419             case 'o':
11420               if (strncmp (KR_keyword, "/dev/sdo13", 10) == 0)
11421                 {
11422 {
11423 return dev_storage + 437;
11424
11425 }
11426                 }
11427               else
11428                 {
11429 {
11430 return  NULL;
11431
11432 }
11433                 }
11434             case 'n':
11435               if (strncmp (KR_keyword, "/dev/sdn13", 10) == 0)
11436                 {
11437 {
11438 return dev_storage + 422;
11439
11440 }
11441                 }
11442               else
11443                 {
11444 {
11445 return  NULL;
11446
11447 }
11448                 }
11449             case 'm':
11450               switch (KR_keyword [5])
11451                 {
11452                 case 's':
11453                   if (strncmp (KR_keyword, "/dev/sdm13", 10) == 0)
11454                     {
11455 {
11456 return dev_storage + 407;
11457
11458 }
11459                     }
11460                   else
11461                     {
11462 {
11463 return  NULL;
11464
11465 }
11466                     }
11467                 case 'c':
11468                   if (strncmp (KR_keyword, "/dev/com13", 10) == 0)
11469                     {
11470 {
11471 return dev_storage + 13;
11472
11473 }
11474                     }
11475                   else
11476                     {
11477 {
11478 return  NULL;
11479
11480 }
11481                     }
11482                 default:
11483 {
11484 return  NULL;
11485
11486 }
11487                 }
11488             case 'l':
11489               if (strncmp (KR_keyword, "/dev/sdl13", 10) == 0)
11490                 {
11491 {
11492 return dev_storage + 392;
11493
11494 }
11495                 }
11496               else
11497                 {
11498 {
11499 return  NULL;
11500
11501 }
11502                 }
11503             case 'k':
11504               if (strncmp (KR_keyword, "/dev/sdk13", 10) == 0)
11505                 {
11506 {
11507 return dev_storage + 377;
11508
11509 }
11510                 }
11511               else
11512                 {
11513 {
11514 return  NULL;
11515
11516 }
11517                 }
11518             case 'j':
11519               if (strncmp (KR_keyword, "/dev/sdj13", 10) == 0)
11520                 {
11521 {
11522 return dev_storage + 362;
11523
11524 }
11525                 }
11526               else
11527                 {
11528 {
11529 return  NULL;
11530
11531 }
11532                 }
11533             case 'i':
11534               if (strncmp (KR_keyword, "/dev/sdi13", 10) == 0)
11535                 {
11536 {
11537 return dev_storage + 347;
11538
11539 }
11540                 }
11541               else
11542                 {
11543 {
11544 return  NULL;
11545
11546 }
11547                 }
11548             case 'h':
11549               if (strncmp (KR_keyword, "/dev/sdh13", 10) == 0)
11550                 {
11551 {
11552 return dev_storage + 332;
11553
11554 }
11555                 }
11556               else
11557                 {
11558 {
11559 return  NULL;
11560
11561 }
11562                 }
11563             case 'g':
11564               if (strncmp (KR_keyword, "/dev/sdg13", 10) == 0)
11565                 {
11566 {
11567 return dev_storage + 317;
11568
11569 }
11570                 }
11571               else
11572                 {
11573 {
11574 return  NULL;
11575
11576 }
11577                 }
11578             case 'f':
11579               if (strncmp (KR_keyword, "/dev/sdf13", 10) == 0)
11580                 {
11581 {
11582 return dev_storage + 302;
11583
11584 }
11585                 }
11586               else
11587                 {
11588 {
11589 return  NULL;
11590
11591 }
11592                 }
11593             case 'e':
11594               if (strncmp (KR_keyword, "/dev/sde13", 10) == 0)
11595                 {
11596 {
11597 return dev_storage + 287;
11598
11599 }
11600                 }
11601               else
11602                 {
11603 {
11604 return  NULL;
11605
11606 }
11607                 }
11608             case 'd':
11609               switch (KR_keyword [6])
11610                 {
11611                 case 'd':
11612                   if (strncmp (KR_keyword, "/dev/sdd13", 10) == 0)
11613                     {
11614 {
11615 return dev_storage + 272;
11616
11617 }
11618                     }
11619                   else
11620                     {
11621 {
11622 return  NULL;
11623
11624 }
11625                     }
11626                 case 'c':
11627                   if (strncmp (KR_keyword, "/dev/scd13", 10) == 0)
11628                     {
11629 {
11630 return dev_storage + 186;
11631
11632 }
11633                     }
11634                   else
11635                     {
11636 {
11637 return  NULL;
11638
11639 }
11640                     }
11641                 default:
11642 {
11643 return  NULL;
11644
11645 }
11646                 }
11647             case 'c':
11648               if (strncmp (KR_keyword, "/dev/sdc13", 10) == 0)
11649                 {
11650 {
11651 return dev_storage + 257;
11652
11653 }
11654                 }
11655               else
11656                 {
11657 {
11658 return  NULL;
11659
11660 }
11661                 }
11662             case 'b':
11663               if (strncmp (KR_keyword, "/dev/sdb13", 10) == 0)
11664                 {
11665 {
11666 return dev_storage + 242;
11667
11668 }
11669                 }
11670               else
11671                 {
11672 {
11673 return  NULL;
11674
11675 }
11676                 }
11677             case 'a':
11678               if (strncmp (KR_keyword, "/dev/sda13", 10) == 0)
11679                 {
11680 {
11681 return dev_storage + 227;
11682
11683 }
11684                 }
11685               else
11686                 {
11687 {
11688 return  NULL;
11689
11690 }
11691                 }
11692             case '1':
11693               switch (KR_keyword [8])
11694                 {
11695                 case '2':
11696                   if (strncmp (KR_keyword, "/dev/st123", 10) == 0)
11697                     {
11698 {
11699 return dev_storage + 744;
11700
11701 }
11702                     }
11703                   else
11704                     {
11705 {
11706 return  NULL;
11707
11708 }
11709                     }
11710                 case '1':
11711                   if (strncmp (KR_keyword, "/dev/st113", 10) == 0)
11712                     {
11713 {
11714 return dev_storage + 734;
11715
11716 }
11717                     }
11718                   else
11719                     {
11720 {
11721 return  NULL;
11722
11723 }
11724                     }
11725                 case '0':
11726                   if (strncmp (KR_keyword, "/dev/st103", 10) == 0)
11727                     {
11728 {
11729 return dev_storage + 724;
11730
11731 }
11732                     }
11733                   else
11734                     {
11735 {
11736 return  NULL;
11737
11738 }
11739                     }
11740                 default:
11741 {
11742 return  NULL;
11743
11744 }
11745                 }
11746             default:
11747 {
11748 return  NULL;
11749
11750 }
11751             }
11752         case '2':
11753           switch (KR_keyword [7])
11754             {
11755             case 'z':
11756               if (strncmp (KR_keyword, "/dev/sdz12", 10) == 0)
11757                 {
11758 {
11759 return dev_storage + 601;
11760
11761 }
11762                 }
11763               else
11764                 {
11765 {
11766 return  NULL;
11767
11768 }
11769                 }
11770             case 'y':
11771               switch (KR_keyword [8])
11772                 {
11773                 case 'S':
11774                   if (strncmp (KR_keyword, "/dev/ttyS2", 10) == 0)
11775                     {
11776 {
11777 return dev_storage + 816;
11778
11779 }
11780                     }
11781                   else
11782                     {
11783 {
11784 return  NULL;
11785
11786 }
11787                     }
11788                 case '6':
11789                   if (strncmp (KR_keyword, "/dev/tty62", 10) == 0)
11790                     {
11791 {
11792 return dev_storage + 812;
11793
11794 }
11795                     }
11796                   else
11797                     {
11798 {
11799 return  NULL;
11800
11801 }
11802                     }
11803                 case '5':
11804                   if (strncmp (KR_keyword, "/dev/tty52", 10) == 0)
11805                     {
11806 {
11807 return dev_storage + 802;
11808
11809 }
11810                     }
11811                   else
11812                     {
11813 {
11814 return  NULL;
11815
11816 }
11817                     }
11818                 case '4':
11819                   if (strncmp (KR_keyword, "/dev/tty42", 10) == 0)
11820                     {
11821 {
11822 return dev_storage + 792;
11823
11824 }
11825                     }
11826                   else
11827                     {
11828 {
11829 return  NULL;
11830
11831 }
11832                     }
11833                 case '3':
11834                   if (strncmp (KR_keyword, "/dev/tty32", 10) == 0)
11835                     {
11836 {
11837 return dev_storage + 782;
11838
11839 }
11840                     }
11841                   else
11842                     {
11843 {
11844 return  NULL;
11845
11846 }
11847                     }
11848                 case '2':
11849                   if (strncmp (KR_keyword, "/dev/tty22", 10) == 0)
11850                     {
11851 {
11852 return dev_storage + 772;
11853
11854 }
11855                     }
11856                   else
11857                     {
11858 {
11859 return  NULL;
11860
11861 }
11862                     }
11863                 case '1':
11864                   switch (KR_keyword [5])
11865                     {
11866                     case 't':
11867                       if (strncmp (KR_keyword, "/dev/tty12", 10) == 0)
11868                         {
11869 {
11870 return dev_storage + 762;
11871
11872 }
11873                         }
11874                       else
11875                         {
11876 {
11877 return  NULL;
11878
11879 }
11880                         }
11881                     case 's':
11882                       if (strncmp (KR_keyword, "/dev/sdy12", 10) == 0)
11883                         {
11884 {
11885 return dev_storage + 586;
11886
11887 }
11888                         }
11889                       else
11890                         {
11891 {
11892 return  NULL;
11893
11894 }
11895                         }
11896                     default:
11897 {
11898 return  NULL;
11899
11900 }
11901                     }
11902                 default:
11903 {
11904 return  NULL;
11905
11906 }
11907                 }
11908             case 'x':
11909               if (strncmp (KR_keyword, "/dev/sdx12", 10) == 0)
11910                 {
11911 {
11912 return dev_storage + 571;
11913
11914 }
11915                 }
11916               else
11917                 {
11918 {
11919 return  NULL;
11920
11921 }
11922                 }
11923             case 'w':
11924               if (strncmp (KR_keyword, "/dev/sdw12", 10) == 0)
11925                 {
11926 {
11927 return dev_storage + 556;
11928
11929 }
11930                 }
11931               else
11932                 {
11933 {
11934 return  NULL;
11935
11936 }
11937                 }
11938             case 'v':
11939               if (strncmp (KR_keyword, "/dev/sdv12", 10) == 0)
11940                 {
11941 {
11942 return dev_storage + 541;
11943
11944 }
11945                 }
11946               else
11947                 {
11948 {
11949 return  NULL;
11950
11951 }
11952                 }
11953             case 'u':
11954               if (strncmp (KR_keyword, "/dev/sdu12", 10) == 0)
11955                 {
11956 {
11957 return dev_storage + 526;
11958
11959 }
11960                 }
11961               else
11962                 {
11963 {
11964 return  NULL;
11965
11966 }
11967                 }
11968             case 't':
11969               switch (KR_keyword [8])
11970                 {
11971                 case '9':
11972                   if (strncmp (KR_keyword, "/dev/nst92", 10) == 0)
11973                     {
11974 {
11975 return dev_storage + 132;
11976
11977 }
11978                     }
11979                   else
11980                     {
11981 {
11982 return  NULL;
11983
11984 }
11985                     }
11986                 case '8':
11987                   if (strncmp (KR_keyword, "/dev/nst82", 10) == 0)
11988                     {
11989 {
11990 return dev_storage + 122;
11991
11992 }
11993                     }
11994                   else
11995                     {
11996 {
11997 return  NULL;
11998
11999 }
12000                     }
12001                 case '7':
12002                   if (strncmp (KR_keyword, "/dev/nst72", 10) == 0)
12003                     {
12004 {
12005 return dev_storage + 112;
12006
12007 }
12008                     }
12009                   else
12010                     {
12011 {
12012 return  NULL;
12013
12014 }
12015                     }
12016                 case '6':
12017                   if (strncmp (KR_keyword, "/dev/nst62", 10) == 0)
12018                     {
12019 {
12020 return dev_storage + 102;
12021
12022 }
12023                     }
12024                   else
12025                     {
12026 {
12027 return  NULL;
12028
12029 }
12030                     }
12031                 case '5':
12032                   if (strncmp (KR_keyword, "/dev/nst52", 10) == 0)
12033                     {
12034 {
12035 return dev_storage + 92;
12036
12037 }
12038                     }
12039                   else
12040                     {
12041 {
12042 return  NULL;
12043
12044 }
12045                     }
12046                 case '4':
12047                   if (strncmp (KR_keyword, "/dev/nst42", 10) == 0)
12048                     {
12049 {
12050 return dev_storage + 82;
12051
12052 }
12053                     }
12054                   else
12055                     {
12056 {
12057 return  NULL;
12058
12059 }
12060                     }
12061                 case '3':
12062                   if (strncmp (KR_keyword, "/dev/nst32", 10) == 0)
12063                     {
12064 {
12065 return dev_storage + 72;
12066
12067 }
12068                     }
12069                   else
12070                     {
12071 {
12072 return  NULL;
12073
12074 }
12075                     }
12076                 case '2':
12077                   if (strncmp (KR_keyword, "/dev/nst22", 10) == 0)
12078                     {
12079 {
12080 return dev_storage + 62;
12081
12082 }
12083                     }
12084                   else
12085                     {
12086 {
12087 return  NULL;
12088
12089 }
12090                     }
12091                 case '1':
12092                   switch (KR_keyword [5])
12093                     {
12094                     case 's':
12095                       if (strncmp (KR_keyword, "/dev/sdt12", 10) == 0)
12096                         {
12097 {
12098 return dev_storage + 511;
12099
12100 }
12101                         }
12102                       else
12103                         {
12104 {
12105 return  NULL;
12106
12107 }
12108                         }
12109                     case 'n':
12110                       if (strncmp (KR_keyword, "/dev/nst12", 10) == 0)
12111                         {
12112 {
12113 return dev_storage + 52;
12114
12115 }
12116                         }
12117                       else
12118                         {
12119 {
12120 return  NULL;
12121
12122 }
12123                         }
12124                     default:
12125 {
12126 return  NULL;
12127
12128 }
12129                     }
12130                 default:
12131 {
12132 return  NULL;
12133
12134 }
12135                 }
12136             case 's':
12137               if (strncmp (KR_keyword, "/dev/sds12", 10) == 0)
12138                 {
12139 {
12140 return dev_storage + 496;
12141
12142 }
12143                 }
12144               else
12145                 {
12146 {
12147 return  NULL;
12148
12149 }
12150                 }
12151             case 'r':
12152               if (strncmp (KR_keyword, "/dev/sdr12", 10) == 0)
12153                 {
12154 {
12155 return dev_storage + 481;
12156
12157 }
12158                 }
12159               else
12160                 {
12161 {
12162 return  NULL;
12163
12164 }
12165                 }
12166             case 'q':
12167               if (strncmp (KR_keyword, "/dev/sdq12", 10) == 0)
12168                 {
12169 {
12170 return dev_storage + 466;
12171
12172 }
12173                 }
12174               else
12175                 {
12176 {
12177 return  NULL;
12178
12179 }
12180                 }
12181             case 'p':
12182               if (strncmp (KR_keyword, "/dev/sdp12", 10) == 0)
12183                 {
12184 {
12185 return dev_storage + 451;
12186
12187 }
12188                 }
12189               else
12190                 {
12191 {
12192 return  NULL;
12193
12194 }
12195                 }
12196             case 'o':
12197               if (strncmp (KR_keyword, "/dev/sdo12", 10) == 0)
12198                 {
12199 {
12200 return dev_storage + 436;
12201
12202 }
12203                 }
12204               else
12205                 {
12206 {
12207 return  NULL;
12208
12209 }
12210                 }
12211             case 'n':
12212               if (strncmp (KR_keyword, "/dev/sdn12", 10) == 0)
12213                 {
12214 {
12215 return dev_storage + 421;
12216
12217 }
12218                 }
12219               else
12220                 {
12221 {
12222 return  NULL;
12223
12224 }
12225                 }
12226             case 'm':
12227               switch (KR_keyword [5])
12228                 {
12229                 case 's':
12230                   if (strncmp (KR_keyword, "/dev/sdm12", 10) == 0)
12231                     {
12232 {
12233 return dev_storage + 406;
12234
12235 }
12236                     }
12237                   else
12238                     {
12239 {
12240 return  NULL;
12241
12242 }
12243                     }
12244                 case 'c':
12245                   if (strncmp (KR_keyword, "/dev/com12", 10) == 0)
12246                     {
12247 {
12248 return dev_storage + 12;
12249
12250 }
12251                     }
12252                   else
12253                     {
12254 {
12255 return  NULL;
12256
12257 }
12258                     }
12259                 default:
12260 {
12261 return  NULL;
12262
12263 }
12264                 }
12265             case 'l':
12266               if (strncmp (KR_keyword, "/dev/sdl12", 10) == 0)
12267                 {
12268 {
12269 return dev_storage + 391;
12270
12271 }
12272                 }
12273               else
12274                 {
12275 {
12276 return  NULL;
12277
12278 }
12279                 }
12280             case 'k':
12281               if (strncmp (KR_keyword, "/dev/sdk12", 10) == 0)
12282                 {
12283 {
12284 return dev_storage + 376;
12285
12286 }
12287                 }
12288               else
12289                 {
12290 {
12291 return  NULL;
12292
12293 }
12294                 }
12295             case 'j':
12296               if (strncmp (KR_keyword, "/dev/sdj12", 10) == 0)
12297                 {
12298 {
12299 return dev_storage + 361;
12300
12301 }
12302                 }
12303               else
12304                 {
12305 {
12306 return  NULL;
12307
12308 }
12309                 }
12310             case 'i':
12311               if (strncmp (KR_keyword, "/dev/sdi12", 10) == 0)
12312                 {
12313 {
12314 return dev_storage + 346;
12315
12316 }
12317                 }
12318               else
12319                 {
12320 {
12321 return  NULL;
12322
12323 }
12324                 }
12325             case 'h':
12326               if (strncmp (KR_keyword, "/dev/sdh12", 10) == 0)
12327                 {
12328 {
12329 return dev_storage + 331;
12330
12331 }
12332                 }
12333               else
12334                 {
12335 {
12336 return  NULL;
12337
12338 }
12339                 }
12340             case 'g':
12341               if (strncmp (KR_keyword, "/dev/sdg12", 10) == 0)
12342                 {
12343 {
12344 return dev_storage + 316;
12345
12346 }
12347                 }
12348               else
12349                 {
12350 {
12351 return  NULL;
12352
12353 }
12354                 }
12355             case 'f':
12356               if (strncmp (KR_keyword, "/dev/sdf12", 10) == 0)
12357                 {
12358 {
12359 return dev_storage + 301;
12360
12361 }
12362                 }
12363               else
12364                 {
12365 {
12366 return  NULL;
12367
12368 }
12369                 }
12370             case 'e':
12371               if (strncmp (KR_keyword, "/dev/sde12", 10) == 0)
12372                 {
12373 {
12374 return dev_storage + 286;
12375
12376 }
12377                 }
12378               else
12379                 {
12380 {
12381 return  NULL;
12382
12383 }
12384                 }
12385             case 'd':
12386               switch (KR_keyword [6])
12387                 {
12388                 case 'd':
12389                   if (strncmp (KR_keyword, "/dev/sdd12", 10) == 0)
12390                     {
12391 {
12392 return dev_storage + 271;
12393
12394 }
12395                     }
12396                   else
12397                     {
12398 {
12399 return  NULL;
12400
12401 }
12402                     }
12403                 case 'c':
12404                   if (strncmp (KR_keyword, "/dev/scd12", 10) == 0)
12405                     {
12406 {
12407 return dev_storage + 185;
12408
12409 }
12410                     }
12411                   else
12412                     {
12413 {
12414 return  NULL;
12415
12416 }
12417                     }
12418                 default:
12419 {
12420 return  NULL;
12421
12422 }
12423                 }
12424             case 'c':
12425               if (strncmp (KR_keyword, "/dev/sdc12", 10) == 0)
12426                 {
12427 {
12428 return dev_storage + 256;
12429
12430 }
12431                 }
12432               else
12433                 {
12434 {
12435 return  NULL;
12436
12437 }
12438                 }
12439             case 'b':
12440               if (strncmp (KR_keyword, "/dev/sdb12", 10) == 0)
12441                 {
12442 {
12443 return dev_storage + 241;
12444
12445 }
12446                 }
12447               else
12448                 {
12449 {
12450 return  NULL;
12451
12452 }
12453                 }
12454             case 'a':
12455               if (strncmp (KR_keyword, "/dev/sda12", 10) == 0)
12456                 {
12457 {
12458 return dev_storage + 226;
12459
12460 }
12461                 }
12462               else
12463                 {
12464 {
12465 return  NULL;
12466
12467 }
12468                 }
12469             case '1':
12470               switch (KR_keyword [8])
12471                 {
12472                 case '2':
12473                   if (strncmp (KR_keyword, "/dev/st122", 10) == 0)
12474                     {
12475 {
12476 return dev_storage + 743;
12477
12478 }
12479                     }
12480                   else
12481                     {
12482 {
12483 return  NULL;
12484
12485 }
12486                     }
12487                 case '1':
12488                   if (strncmp (KR_keyword, "/dev/st112", 10) == 0)
12489                     {
12490 {
12491 return dev_storage + 733;
12492
12493 }
12494                     }
12495                   else
12496                     {
12497 {
12498 return  NULL;
12499
12500 }
12501                     }
12502                 case '0':
12503                   if (strncmp (KR_keyword, "/dev/st102", 10) == 0)
12504                     {
12505 {
12506 return dev_storage + 723;
12507
12508 }
12509                     }
12510                   else
12511                     {
12512 {
12513 return  NULL;
12514
12515 }
12516                     }
12517                 default:
12518 {
12519 return  NULL;
12520
12521 }
12522                 }
12523             default:
12524 {
12525 return  NULL;
12526
12527 }
12528             }
12529         case '1':
12530           switch (KR_keyword [7])
12531             {
12532             case 'z':
12533               if (strncmp (KR_keyword, "/dev/sdz11", 10) == 0)
12534                 {
12535 {
12536 return dev_storage + 600;
12537
12538 }
12539                 }
12540               else
12541                 {
12542 {
12543 return  NULL;
12544
12545 }
12546                 }
12547             case 'y':
12548               switch (KR_keyword [8])
12549                 {
12550                 case 'S':
12551                   if (strncmp (KR_keyword, "/dev/ttyS1", 10) == 0)
12552                     {
12553 {
12554 return dev_storage + 815;
12555
12556 }
12557                     }
12558                   else
12559                     {
12560 {
12561 return  NULL;
12562
12563 }
12564                     }
12565                 case '6':
12566                   if (strncmp (KR_keyword, "/dev/tty61", 10) == 0)
12567                     {
12568 {
12569 return dev_storage + 811;
12570
12571 }
12572                     }
12573                   else
12574                     {
12575 {
12576 return  NULL;
12577
12578 }
12579                     }
12580                 case '5':
12581                   if (strncmp (KR_keyword, "/dev/tty51", 10) == 0)
12582                     {
12583 {
12584 return dev_storage + 801;
12585
12586 }
12587                     }
12588                   else
12589                     {
12590 {
12591 return  NULL;
12592
12593 }
12594                     }
12595                 case '4':
12596                   if (strncmp (KR_keyword, "/dev/tty41", 10) == 0)
12597                     {
12598 {
12599 return dev_storage + 791;
12600
12601 }
12602                     }
12603                   else
12604                     {
12605 {
12606 return  NULL;
12607
12608 }
12609                     }
12610                 case '3':
12611                   if (strncmp (KR_keyword, "/dev/tty31", 10) == 0)
12612                     {
12613 {
12614 return dev_storage + 781;
12615
12616 }
12617                     }
12618                   else
12619                     {
12620 {
12621 return  NULL;
12622
12623 }
12624                     }
12625                 case '2':
12626                   if (strncmp (KR_keyword, "/dev/tty21", 10) == 0)
12627                     {
12628 {
12629 return dev_storage + 771;
12630
12631 }
12632                     }
12633                   else
12634                     {
12635 {
12636 return  NULL;
12637
12638 }
12639                     }
12640                 case '1':
12641                   switch (KR_keyword [5])
12642                     {
12643                     case 't':
12644                       if (strncmp (KR_keyword, "/dev/tty11", 10) == 0)
12645                         {
12646 {
12647 return dev_storage + 761;
12648
12649 }
12650                         }
12651                       else
12652                         {
12653 {
12654 return  NULL;
12655
12656 }
12657                         }
12658                     case 's':
12659                       if (strncmp (KR_keyword, "/dev/sdy11", 10) == 0)
12660                         {
12661 {
12662 return dev_storage + 585;
12663
12664 }
12665                         }
12666                       else
12667                         {
12668 {
12669 return  NULL;
12670
12671 }
12672                         }
12673                     default:
12674 {
12675 return  NULL;
12676
12677 }
12678                     }
12679                 default:
12680 {
12681 return  NULL;
12682
12683 }
12684                 }
12685             case 'x':
12686               if (strncmp (KR_keyword, "/dev/sdx11", 10) == 0)
12687                 {
12688 {
12689 return dev_storage + 570;
12690
12691 }
12692                 }
12693               else
12694                 {
12695 {
12696 return  NULL;
12697
12698 }
12699                 }
12700             case 'w':
12701               if (strncmp (KR_keyword, "/dev/sdw11", 10) == 0)
12702                 {
12703 {
12704 return dev_storage + 555;
12705
12706 }
12707                 }
12708               else
12709                 {
12710 {
12711 return  NULL;
12712
12713 }
12714                 }
12715             case 'v':
12716               if (strncmp (KR_keyword, "/dev/sdv11", 10) == 0)
12717                 {
12718 {
12719 return dev_storage + 540;
12720
12721 }
12722                 }
12723               else
12724                 {
12725 {
12726 return  NULL;
12727
12728 }
12729                 }
12730             case 'u':
12731               if (strncmp (KR_keyword, "/dev/sdu11", 10) == 0)
12732                 {
12733 {
12734 return dev_storage + 525;
12735
12736 }
12737                 }
12738               else
12739                 {
12740 {
12741 return  NULL;
12742
12743 }
12744                 }
12745             case 't':
12746               switch (KR_keyword [8])
12747                 {
12748                 case '9':
12749                   if (strncmp (KR_keyword, "/dev/nst91", 10) == 0)
12750                     {
12751 {
12752 return dev_storage + 131;
12753
12754 }
12755                     }
12756                   else
12757                     {
12758 {
12759 return  NULL;
12760
12761 }
12762                     }
12763                 case '8':
12764                   if (strncmp (KR_keyword, "/dev/nst81", 10) == 0)
12765                     {
12766 {
12767 return dev_storage + 121;
12768
12769 }
12770                     }
12771                   else
12772                     {
12773 {
12774 return  NULL;
12775
12776 }
12777                     }
12778                 case '7':
12779                   if (strncmp (KR_keyword, "/dev/nst71", 10) == 0)
12780                     {
12781 {
12782 return dev_storage + 111;
12783
12784 }
12785                     }
12786                   else
12787                     {
12788 {
12789 return  NULL;
12790
12791 }
12792                     }
12793                 case '6':
12794                   if (strncmp (KR_keyword, "/dev/nst61", 10) == 0)
12795                     {
12796 {
12797 return dev_storage + 101;
12798
12799 }
12800                     }
12801                   else
12802                     {
12803 {
12804 return  NULL;
12805
12806 }
12807                     }
12808                 case '5':
12809                   if (strncmp (KR_keyword, "/dev/nst51", 10) == 0)
12810                     {
12811 {
12812 return dev_storage + 91;
12813
12814 }
12815                     }
12816                   else
12817                     {
12818 {
12819 return  NULL;
12820
12821 }
12822                     }
12823                 case '4':
12824                   if (strncmp (KR_keyword, "/dev/nst41", 10) == 0)
12825                     {
12826 {
12827 return dev_storage + 81;
12828
12829 }
12830                     }
12831                   else
12832                     {
12833 {
12834 return  NULL;
12835
12836 }
12837                     }
12838                 case '3':
12839                   if (strncmp (KR_keyword, "/dev/nst31", 10) == 0)
12840                     {
12841 {
12842 return dev_storage + 71;
12843
12844 }
12845                     }
12846                   else
12847                     {
12848 {
12849 return  NULL;
12850
12851 }
12852                     }
12853                 case '2':
12854                   if (strncmp (KR_keyword, "/dev/nst21", 10) == 0)
12855                     {
12856 {
12857 return dev_storage + 61;
12858
12859 }
12860                     }
12861                   else
12862                     {
12863 {
12864 return  NULL;
12865
12866 }
12867                     }
12868                 case '1':
12869                   switch (KR_keyword [5])
12870                     {
12871                     case 's':
12872                       if (strncmp (KR_keyword, "/dev/sdt11", 10) == 0)
12873                         {
12874 {
12875 return dev_storage + 510;
12876
12877 }
12878                         }
12879                       else
12880                         {
12881 {
12882 return  NULL;
12883
12884 }
12885                         }
12886                     case 'n':
12887                       if (strncmp (KR_keyword, "/dev/nst11", 10) == 0)
12888                         {
12889 {
12890 return dev_storage + 51;
12891
12892 }
12893                         }
12894                       else
12895                         {
12896 {
12897 return  NULL;
12898
12899 }
12900                         }
12901                     default:
12902 {
12903 return  NULL;
12904
12905 }
12906                     }
12907                 default:
12908 {
12909 return  NULL;
12910
12911 }
12912                 }
12913             case 's':
12914               if (strncmp (KR_keyword, "/dev/sds11", 10) == 0)
12915                 {
12916 {
12917 return dev_storage + 495;
12918
12919 }
12920                 }
12921               else
12922                 {
12923 {
12924 return  NULL;
12925
12926 }
12927                 }
12928             case 'r':
12929               if (strncmp (KR_keyword, "/dev/sdr11", 10) == 0)
12930                 {
12931 {
12932 return dev_storage + 480;
12933
12934 }
12935                 }
12936               else
12937                 {
12938 {
12939 return  NULL;
12940
12941 }
12942                 }
12943             case 'q':
12944               if (strncmp (KR_keyword, "/dev/sdq11", 10) == 0)
12945                 {
12946 {
12947 return dev_storage + 465;
12948
12949 }
12950                 }
12951               else
12952                 {
12953 {
12954 return  NULL;
12955
12956 }
12957                 }
12958             case 'p':
12959               if (strncmp (KR_keyword, "/dev/sdp11", 10) == 0)
12960                 {
12961 {
12962 return dev_storage + 450;
12963
12964 }
12965                 }
12966               else
12967                 {
12968 {
12969 return  NULL;
12970
12971 }
12972                 }
12973             case 'o':
12974               if (strncmp (KR_keyword, "/dev/sdo11", 10) == 0)
12975                 {
12976 {
12977 return dev_storage + 435;
12978
12979 }
12980                 }
12981               else
12982                 {
12983 {
12984 return  NULL;
12985
12986 }
12987                 }
12988             case 'n':
12989               if (strncmp (KR_keyword, "/dev/sdn11", 10) == 0)
12990                 {
12991 {
12992 return dev_storage + 420;
12993
12994 }
12995                 }
12996               else
12997                 {
12998 {
12999 return  NULL;
13000
13001 }
13002                 }
13003             case 'm':
13004               switch (KR_keyword [5])
13005                 {
13006                 case 's':
13007                   if (strncmp (KR_keyword, "/dev/sdm11", 10) == 0)
13008                     {
13009 {
13010 return dev_storage + 405;
13011
13012 }
13013                     }
13014                   else
13015                     {
13016 {
13017 return  NULL;
13018
13019 }
13020                     }
13021                 case 'c':
13022                   if (strncmp (KR_keyword, "/dev/com11", 10) == 0)
13023                     {
13024 {
13025 return dev_storage + 11;
13026
13027 }
13028                     }
13029                   else
13030                     {
13031 {
13032 return  NULL;
13033
13034 }
13035                     }
13036                 default:
13037 {
13038 return  NULL;
13039
13040 }
13041                 }
13042             case 'l':
13043               if (strncmp (KR_keyword, "/dev/sdl11", 10) == 0)
13044                 {
13045 {
13046 return dev_storage + 390;
13047
13048 }
13049                 }
13050               else
13051                 {
13052 {
13053 return  NULL;
13054
13055 }
13056                 }
13057             case 'k':
13058               if (strncmp (KR_keyword, "/dev/sdk11", 10) == 0)
13059                 {
13060 {
13061 return dev_storage + 375;
13062
13063 }
13064                 }
13065               else
13066                 {
13067 {
13068 return  NULL;
13069
13070 }
13071                 }
13072             case 'j':
13073               if (strncmp (KR_keyword, "/dev/sdj11", 10) == 0)
13074                 {
13075 {
13076 return dev_storage + 360;
13077
13078 }
13079                 }
13080               else
13081                 {
13082 {
13083 return  NULL;
13084
13085 }
13086                 }
13087             case 'i':
13088               if (strncmp (KR_keyword, "/dev/sdi11", 10) == 0)
13089                 {
13090 {
13091 return dev_storage + 345;
13092
13093 }
13094                 }
13095               else
13096                 {
13097 {
13098 return  NULL;
13099
13100 }
13101                 }
13102             case 'h':
13103               if (strncmp (KR_keyword, "/dev/sdh11", 10) == 0)
13104                 {
13105 {
13106 return dev_storage + 330;
13107
13108 }
13109                 }
13110               else
13111                 {
13112 {
13113 return  NULL;
13114
13115 }
13116                 }
13117             case 'g':
13118               if (strncmp (KR_keyword, "/dev/sdg11", 10) == 0)
13119                 {
13120 {
13121 return dev_storage + 315;
13122
13123 }
13124                 }
13125               else
13126                 {
13127 {
13128 return  NULL;
13129
13130 }
13131                 }
13132             case 'f':
13133               if (strncmp (KR_keyword, "/dev/sdf11", 10) == 0)
13134                 {
13135 {
13136 return dev_storage + 300;
13137
13138 }
13139                 }
13140               else
13141                 {
13142 {
13143 return  NULL;
13144
13145 }
13146                 }
13147             case 'e':
13148               if (strncmp (KR_keyword, "/dev/sde11", 10) == 0)
13149                 {
13150 {
13151 return dev_storage + 285;
13152
13153 }
13154                 }
13155               else
13156                 {
13157 {
13158 return  NULL;
13159
13160 }
13161                 }
13162             case 'd':
13163               switch (KR_keyword [6])
13164                 {
13165                 case 'd':
13166                   if (strncmp (KR_keyword, "/dev/sdd11", 10) == 0)
13167                     {
13168 {
13169 return dev_storage + 270;
13170
13171 }
13172                     }
13173                   else
13174                     {
13175 {
13176 return  NULL;
13177
13178 }
13179                     }
13180                 case 'c':
13181                   if (strncmp (KR_keyword, "/dev/scd11", 10) == 0)
13182                     {
13183 {
13184 return dev_storage + 184;
13185
13186 }
13187                     }
13188                   else
13189                     {
13190 {
13191 return  NULL;
13192
13193 }
13194                     }
13195                 default:
13196 {
13197 return  NULL;
13198
13199 }
13200                 }
13201             case 'c':
13202               if (strncmp (KR_keyword, "/dev/sdc11", 10) == 0)
13203                 {
13204 {
13205 return dev_storage + 255;
13206
13207 }
13208                 }
13209               else
13210                 {
13211 {
13212 return  NULL;
13213
13214 }
13215                 }
13216             case 'b':
13217               if (strncmp (KR_keyword, "/dev/sdb11", 10) == 0)
13218                 {
13219 {
13220 return dev_storage + 240;
13221
13222 }
13223                 }
13224               else
13225                 {
13226 {
13227 return  NULL;
13228
13229 }
13230                 }
13231             case 'a':
13232               if (strncmp (KR_keyword, "/dev/sda11", 10) == 0)
13233                 {
13234 {
13235 return dev_storage + 225;
13236
13237 }
13238                 }
13239               else
13240                 {
13241 {
13242 return  NULL;
13243
13244 }
13245                 }
13246             case '1':
13247               switch (KR_keyword [8])
13248                 {
13249                 case '2':
13250                   if (strncmp (KR_keyword, "/dev/st121", 10) == 0)
13251                     {
13252 {
13253 return dev_storage + 742;
13254
13255 }
13256                     }
13257                   else
13258                     {
13259 {
13260 return  NULL;
13261
13262 }
13263                     }
13264                 case '1':
13265                   if (strncmp (KR_keyword, "/dev/st111", 10) == 0)
13266                     {
13267 {
13268 return dev_storage + 732;
13269
13270 }
13271                     }
13272                   else
13273                     {
13274 {
13275 return  NULL;
13276
13277 }
13278                     }
13279                 case '0':
13280                   if (strncmp (KR_keyword, "/dev/st101", 10) == 0)
13281                     {
13282 {
13283 return dev_storage + 722;
13284
13285 }
13286                     }
13287                   else
13288                     {
13289 {
13290 return  NULL;
13291
13292 }
13293                     }
13294                 default:
13295 {
13296 return  NULL;
13297
13298 }
13299                 }
13300             default:
13301 {
13302 return  NULL;
13303
13304 }
13305             }
13306         case '0':
13307           switch (KR_keyword [7])
13308             {
13309             case 'z':
13310               if (strncmp (KR_keyword, "/dev/sdz10", 10) == 0)
13311                 {
13312 {
13313 return dev_storage + 599;
13314
13315 }
13316                 }
13317               else
13318                 {
13319 {
13320 return  NULL;
13321
13322 }
13323                 }
13324             case 'y':
13325               switch (KR_keyword [8])
13326                 {
13327                 case 'S':
13328                   if (strncmp (KR_keyword, "/dev/ttyS0", 10) == 0)
13329                     {
13330 {
13331 return dev_storage + 814;
13332
13333 }
13334                     }
13335                   else
13336                     {
13337 {
13338 return  NULL;
13339
13340 }
13341                     }
13342                 case '6':
13343                   if (strncmp (KR_keyword, "/dev/tty60", 10) == 0)
13344                     {
13345 {
13346 return dev_storage + 810;
13347
13348 }
13349                     }
13350                   else
13351                     {
13352 {
13353 return  NULL;
13354
13355 }
13356                     }
13357                 case '5':
13358                   if (strncmp (KR_keyword, "/dev/tty50", 10) == 0)
13359                     {
13360 {
13361 return dev_storage + 800;
13362
13363 }
13364                     }
13365                   else
13366                     {
13367 {
13368 return  NULL;
13369
13370 }
13371                     }
13372                 case '4':
13373                   if (strncmp (KR_keyword, "/dev/tty40", 10) == 0)
13374                     {
13375 {
13376 return dev_storage + 790;
13377
13378 }
13379                     }
13380                   else
13381                     {
13382 {
13383 return  NULL;
13384
13385 }
13386                     }
13387                 case '3':
13388                   if (strncmp (KR_keyword, "/dev/tty30", 10) == 0)
13389                     {
13390 {
13391 return dev_storage + 780;
13392
13393 }
13394                     }
13395                   else
13396                     {
13397 {
13398 return  NULL;
13399
13400 }
13401                     }
13402                 case '2':
13403                   if (strncmp (KR_keyword, "/dev/tty20", 10) == 0)
13404                     {
13405 {
13406 return dev_storage + 770;
13407
13408 }
13409                     }
13410                   else
13411                     {
13412 {
13413 return  NULL;
13414
13415 }
13416                     }
13417                 case '1':
13418                   switch (KR_keyword [5])
13419                     {
13420                     case 't':
13421                       if (strncmp (KR_keyword, "/dev/tty10", 10) == 0)
13422                         {
13423 {
13424 return dev_storage + 760;
13425
13426 }
13427                         }
13428                       else
13429                         {
13430 {
13431 return  NULL;
13432
13433 }
13434                         }
13435                     case 's':
13436                       if (strncmp (KR_keyword, "/dev/sdy10", 10) == 0)
13437                         {
13438 {
13439 return dev_storage + 584;
13440
13441 }
13442                         }
13443                       else
13444                         {
13445 {
13446 return  NULL;
13447
13448 }
13449                         }
13450                     default:
13451 {
13452 return  NULL;
13453
13454 }
13455                     }
13456                 default:
13457 {
13458 return  NULL;
13459
13460 }
13461                 }
13462             case 'x':
13463               if (strncmp (KR_keyword, "/dev/sdx10", 10) == 0)
13464                 {
13465 {
13466 return dev_storage + 569;
13467
13468 }
13469                 }
13470               else
13471                 {
13472 {
13473 return  NULL;
13474
13475 }
13476                 }
13477             case 'w':
13478               if (strncmp (KR_keyword, "/dev/sdw10", 10) == 0)
13479                 {
13480 {
13481 return dev_storage + 554;
13482
13483 }
13484                 }
13485               else
13486                 {
13487 {
13488 return  NULL;
13489
13490 }
13491                 }
13492             case 'v':
13493               if (strncmp (KR_keyword, "/dev/sdv10", 10) == 0)
13494                 {
13495 {
13496 return dev_storage + 539;
13497
13498 }
13499                 }
13500               else
13501                 {
13502 {
13503 return  NULL;
13504
13505 }
13506                 }
13507             case 'u':
13508               if (strncmp (KR_keyword, "/dev/sdu10", 10) == 0)
13509                 {
13510 {
13511 return dev_storage + 524;
13512
13513 }
13514                 }
13515               else
13516                 {
13517 {
13518 return  NULL;
13519
13520 }
13521                 }
13522             case 't':
13523               switch (KR_keyword [8])
13524                 {
13525                 case '9':
13526                   if (strncmp (KR_keyword, "/dev/nst90", 10) == 0)
13527                     {
13528 {
13529 return dev_storage + 130;
13530
13531 }
13532                     }
13533                   else
13534                     {
13535 {
13536 return  NULL;
13537
13538 }
13539                     }
13540                 case '8':
13541                   if (strncmp (KR_keyword, "/dev/nst80", 10) == 0)
13542                     {
13543 {
13544 return dev_storage + 120;
13545
13546 }
13547                     }
13548                   else
13549                     {
13550 {
13551 return  NULL;
13552
13553 }
13554                     }
13555                 case '7':
13556                   if (strncmp (KR_keyword, "/dev/nst70", 10) == 0)
13557                     {
13558 {
13559 return dev_storage + 110;
13560
13561 }
13562                     }
13563                   else
13564                     {
13565 {
13566 return  NULL;
13567
13568 }
13569                     }
13570                 case '6':
13571                   if (strncmp (KR_keyword, "/dev/nst60", 10) == 0)
13572                     {
13573 {
13574 return dev_storage + 100;
13575
13576 }
13577                     }
13578                   else
13579                     {
13580 {
13581 return  NULL;
13582
13583 }
13584                     }
13585                 case '5':
13586                   if (strncmp (KR_keyword, "/dev/nst50", 10) == 0)
13587                     {
13588 {
13589 return dev_storage + 90;
13590
13591 }
13592                     }
13593                   else
13594                     {
13595 {
13596 return  NULL;
13597
13598 }
13599                     }
13600                 case '4':
13601                   if (strncmp (KR_keyword, "/dev/nst40", 10) == 0)
13602                     {
13603 {
13604 return dev_storage + 80;
13605
13606 }
13607                     }
13608                   else
13609                     {
13610 {
13611 return  NULL;
13612
13613 }
13614                     }
13615                 case '3':
13616                   if (strncmp (KR_keyword, "/dev/nst30", 10) == 0)
13617                     {
13618 {
13619 return dev_storage + 70;
13620
13621 }
13622                     }
13623                   else
13624                     {
13625 {
13626 return  NULL;
13627
13628 }
13629                     }
13630                 case '2':
13631                   if (strncmp (KR_keyword, "/dev/nst20", 10) == 0)
13632                     {
13633 {
13634 return dev_storage + 60;
13635
13636 }
13637                     }
13638                   else
13639                     {
13640 {
13641 return  NULL;
13642
13643 }
13644                     }
13645                 case '1':
13646                   switch (KR_keyword [5])
13647                     {
13648                     case 's':
13649                       if (strncmp (KR_keyword, "/dev/sdt10", 10) == 0)
13650                         {
13651 {
13652 return dev_storage + 509;
13653
13654 }
13655                         }
13656                       else
13657                         {
13658 {
13659 return  NULL;
13660
13661 }
13662                         }
13663                     case 'n':
13664                       if (strncmp (KR_keyword, "/dev/nst10", 10) == 0)
13665                         {
13666 {
13667 return dev_storage + 50;
13668
13669 }
13670                         }
13671                       else
13672                         {
13673 {
13674 return  NULL;
13675
13676 }
13677                         }
13678                     default:
13679 {
13680 return  NULL;
13681
13682 }
13683                     }
13684                 default:
13685 {
13686 return  NULL;
13687
13688 }
13689                 }
13690             case 's':
13691               if (strncmp (KR_keyword, "/dev/sds10", 10) == 0)
13692                 {
13693 {
13694 return dev_storage + 494;
13695
13696 }
13697                 }
13698               else
13699                 {
13700 {
13701 return  NULL;
13702
13703 }
13704                 }
13705             case 'r':
13706               if (strncmp (KR_keyword, "/dev/sdr10", 10) == 0)
13707                 {
13708 {
13709 return dev_storage + 479;
13710
13711 }
13712                 }
13713               else
13714                 {
13715 {
13716 return  NULL;
13717
13718 }
13719                 }
13720             case 'q':
13721               if (strncmp (KR_keyword, "/dev/sdq10", 10) == 0)
13722                 {
13723 {
13724 return dev_storage + 464;
13725
13726 }
13727                 }
13728               else
13729                 {
13730 {
13731 return  NULL;
13732
13733 }
13734                 }
13735             case 'p':
13736               if (strncmp (KR_keyword, "/dev/sdp10", 10) == 0)
13737                 {
13738 {
13739 return dev_storage + 449;
13740
13741 }
13742                 }
13743               else
13744                 {
13745 {
13746 return  NULL;
13747
13748 }
13749                 }
13750             case 'o':
13751               if (strncmp (KR_keyword, "/dev/sdo10", 10) == 0)
13752                 {
13753 {
13754 return dev_storage + 434;
13755
13756 }
13757                 }
13758               else
13759                 {
13760 {
13761 return  NULL;
13762
13763 }
13764                 }
13765             case 'n':
13766               if (strncmp (KR_keyword, "/dev/sdn10", 10) == 0)
13767                 {
13768 {
13769 return dev_storage + 419;
13770
13771 }
13772                 }
13773               else
13774                 {
13775 {
13776 return  NULL;
13777
13778 }
13779                 }
13780             case 'm':
13781               switch (KR_keyword [5])
13782                 {
13783                 case 's':
13784                   if (strncmp (KR_keyword, "/dev/sdm10", 10) == 0)
13785                     {
13786 {
13787 return dev_storage + 404;
13788
13789 }
13790                     }
13791                   else
13792                     {
13793 {
13794 return  NULL;
13795
13796 }
13797                     }
13798                 case 'c':
13799                   if (strncmp (KR_keyword, "/dev/com10", 10) == 0)
13800                     {
13801 {
13802 return dev_storage + 10;
13803
13804 }
13805                     }
13806                   else
13807                     {
13808 {
13809 return  NULL;
13810
13811 }
13812                     }
13813                 default:
13814 {
13815 return  NULL;
13816
13817 }
13818                 }
13819             case 'l':
13820               if (strncmp (KR_keyword, "/dev/sdl10", 10) == 0)
13821                 {
13822 {
13823 return dev_storage + 389;
13824
13825 }
13826                 }
13827               else
13828                 {
13829 {
13830 return  NULL;
13831
13832 }
13833                 }
13834             case 'k':
13835               if (strncmp (KR_keyword, "/dev/sdk10", 10) == 0)
13836                 {
13837 {
13838 return dev_storage + 374;
13839
13840 }
13841                 }
13842               else
13843                 {
13844 {
13845 return  NULL;
13846
13847 }
13848                 }
13849             case 'j':
13850               if (strncmp (KR_keyword, "/dev/sdj10", 10) == 0)
13851                 {
13852 {
13853 return dev_storage + 359;
13854
13855 }
13856                 }
13857               else
13858                 {
13859 {
13860 return  NULL;
13861
13862 }
13863                 }
13864             case 'i':
13865               if (strncmp (KR_keyword, "/dev/sdi10", 10) == 0)
13866                 {
13867 {
13868 return dev_storage + 344;
13869
13870 }
13871                 }
13872               else
13873                 {
13874 {
13875 return  NULL;
13876
13877 }
13878                 }
13879             case 'h':
13880               if (strncmp (KR_keyword, "/dev/sdh10", 10) == 0)
13881                 {
13882 {
13883 return dev_storage + 329;
13884
13885 }
13886                 }
13887               else
13888                 {
13889 {
13890 return  NULL;
13891
13892 }
13893                 }
13894             case 'g':
13895               if (strncmp (KR_keyword, "/dev/sdg10", 10) == 0)
13896                 {
13897 {
13898 return dev_storage + 314;
13899
13900 }
13901                 }
13902               else
13903                 {
13904 {
13905 return  NULL;
13906
13907 }
13908                 }
13909             case 'f':
13910               if (strncmp (KR_keyword, "/dev/sdf10", 10) == 0)
13911                 {
13912 {
13913 return dev_storage + 299;
13914
13915 }
13916                 }
13917               else
13918                 {
13919 {
13920 return  NULL;
13921
13922 }
13923                 }
13924             case 'e':
13925               if (strncmp (KR_keyword, "/dev/sde10", 10) == 0)
13926                 {
13927 {
13928 return dev_storage + 284;
13929
13930 }
13931                 }
13932               else
13933                 {
13934 {
13935 return  NULL;
13936
13937 }
13938                 }
13939             case 'd':
13940               switch (KR_keyword [6])
13941                 {
13942                 case 'd':
13943                   if (strncmp (KR_keyword, "/dev/sdd10", 10) == 0)
13944                     {
13945 {
13946 return dev_storage + 269;
13947
13948 }
13949                     }
13950                   else
13951                     {
13952 {
13953 return  NULL;
13954
13955 }
13956                     }
13957                 case 'c':
13958                   if (strncmp (KR_keyword, "/dev/scd10", 10) == 0)
13959                     {
13960 {
13961 return dev_storage + 183;
13962
13963 }
13964                     }
13965                   else
13966                     {
13967 {
13968 return  NULL;
13969
13970 }
13971                     }
13972                 default:
13973 {
13974 return  NULL;
13975
13976 }
13977                 }
13978             case 'c':
13979               if (strncmp (KR_keyword, "/dev/sdc10", 10) == 0)
13980                 {
13981 {
13982 return dev_storage + 254;
13983
13984 }
13985                 }
13986               else
13987                 {
13988 {
13989 return  NULL;
13990
13991 }
13992                 }
13993             case 'b':
13994               if (strncmp (KR_keyword, "/dev/sdb10", 10) == 0)
13995                 {
13996 {
13997 return dev_storage + 239;
13998
13999 }
14000                 }
14001               else
14002                 {
14003 {
14004 return  NULL;
14005
14006 }
14007                 }
14008             case 'a':
14009               if (strncmp (KR_keyword, "/dev/sda10", 10) == 0)
14010                 {
14011 {
14012 return dev_storage + 224;
14013
14014 }
14015                 }
14016               else
14017                 {
14018 {
14019 return  NULL;
14020
14021 }
14022                 }
14023             case '1':
14024               switch (KR_keyword [8])
14025                 {
14026                 case '2':
14027                   if (strncmp (KR_keyword, "/dev/st120", 10) == 0)
14028                     {
14029 {
14030 return dev_storage + 741;
14031
14032 }
14033                     }
14034                   else
14035                     {
14036 {
14037 return  NULL;
14038
14039 }
14040                     }
14041                 case '1':
14042                   if (strncmp (KR_keyword, "/dev/st110", 10) == 0)
14043                     {
14044 {
14045 return dev_storage + 731;
14046
14047 }
14048                     }
14049                   else
14050                     {
14051 {
14052 return  NULL;
14053
14054 }
14055                     }
14056                 case '0':
14057                   if (strncmp (KR_keyword, "/dev/st100", 10) == 0)
14058                     {
14059 {
14060 return dev_storage + 721;
14061
14062 }
14063                     }
14064                   else
14065                     {
14066 {
14067 return  NULL;
14068
14069 }
14070                     }
14071                 default:
14072 {
14073 return  NULL;
14074
14075 }
14076                 }
14077             default:
14078 {
14079 return  NULL;
14080
14081 }
14082             }
14083         default:
14084 {
14085 return  NULL;
14086
14087 }
14088         }
14089     case 11:
14090       switch (KR_keyword [9])
14091         {
14092         case 'u':
14093           if (strncmp (KR_keyword, "/dev/conout", 11) == 0)
14094             {
14095 {
14096 return dev_storage + 18;
14097
14098 }
14099             }
14100           else
14101             {
14102 {
14103 return  NULL;
14104
14105 }
14106             }
14107         case 'o':
14108           if (strncmp (KR_keyword, "/dev/random", 11) == 0)
14109             {
14110 {
14111 return dev_storage + 172;
14112
14113 }
14114             }
14115           else
14116             {
14117 {
14118 return  NULL;
14119
14120 }
14121             }
14122         case '2':
14123           switch (KR_keyword [10])
14124             {
14125             case '7':
14126               if (strncmp (KR_keyword, "/dev/nst127", 11) == 0)
14127                 {
14128 {
14129 return dev_storage + 167;
14130
14131 }
14132                 }
14133               else
14134                 {
14135 {
14136 return  NULL;
14137
14138 }
14139                 }
14140             case '6':
14141               if (strncmp (KR_keyword, "/dev/nst126", 11) == 0)
14142                 {
14143 {
14144 return dev_storage + 166;
14145
14146 }
14147                 }
14148               else
14149                 {
14150 {
14151 return  NULL;
14152
14153 }
14154                 }
14155             case '5':
14156               if (strncmp (KR_keyword, "/dev/nst125", 11) == 0)
14157                 {
14158 {
14159 return dev_storage + 165;
14160
14161 }
14162                 }
14163               else
14164                 {
14165 {
14166 return  NULL;
14167
14168 }
14169                 }
14170             case '4':
14171               if (strncmp (KR_keyword, "/dev/nst124", 11) == 0)
14172                 {
14173 {
14174 return dev_storage + 164;
14175
14176 }
14177                 }
14178               else
14179                 {
14180 {
14181 return  NULL;
14182
14183 }
14184                 }
14185             case '3':
14186               if (strncmp (KR_keyword, "/dev/nst123", 11) == 0)
14187                 {
14188 {
14189 return dev_storage + 163;
14190
14191 }
14192                 }
14193               else
14194                 {
14195 {
14196 return  NULL;
14197
14198 }
14199                 }
14200             case '2':
14201               if (strncmp (KR_keyword, "/dev/nst122", 11) == 0)
14202                 {
14203 {
14204 return dev_storage + 162;
14205
14206 }
14207                 }
14208               else
14209                 {
14210 {
14211 return  NULL;
14212
14213 }
14214                 }
14215             case '1':
14216               if (strncmp (KR_keyword, "/dev/nst121", 11) == 0)
14217                 {
14218 {
14219 return dev_storage + 161;
14220
14221 }
14222                 }
14223               else
14224                 {
14225 {
14226 return  NULL;
14227
14228 }
14229                 }
14230             case '0':
14231               if (strncmp (KR_keyword, "/dev/nst120", 11) == 0)
14232                 {
14233 {
14234 return dev_storage + 160;
14235
14236 }
14237                 }
14238               else
14239                 {
14240 {
14241 return  NULL;
14242
14243 }
14244                 }
14245             default:
14246 {
14247 return  NULL;
14248
14249 }
14250             }
14251         case '1':
14252           switch (KR_keyword [10])
14253             {
14254             case '9':
14255               if (strncmp (KR_keyword, "/dev/nst119", 11) == 0)
14256                 {
14257 {
14258 return dev_storage + 159;
14259
14260 }
14261                 }
14262               else
14263                 {
14264 {
14265 return  NULL;
14266
14267 }
14268                 }
14269             case '8':
14270               if (strncmp (KR_keyword, "/dev/nst118", 11) == 0)
14271                 {
14272 {
14273 return dev_storage + 158;
14274
14275 }
14276                 }
14277               else
14278                 {
14279 {
14280 return  NULL;
14281
14282 }
14283                 }
14284             case '7':
14285               if (strncmp (KR_keyword, "/dev/nst117", 11) == 0)
14286                 {
14287 {
14288 return dev_storage + 157;
14289
14290 }
14291                 }
14292               else
14293                 {
14294 {
14295 return  NULL;
14296
14297 }
14298                 }
14299             case '6':
14300               if (strncmp (KR_keyword, "/dev/nst116", 11) == 0)
14301                 {
14302 {
14303 return dev_storage + 156;
14304
14305 }
14306                 }
14307               else
14308                 {
14309 {
14310 return  NULL;
14311
14312 }
14313                 }
14314             case '5':
14315               switch (KR_keyword [5])
14316                 {
14317                 case 't':
14318                   if (strncmp (KR_keyword, "/dev/ttyS15", 11) == 0)
14319                     {
14320 {
14321 return dev_storage + 829;
14322
14323 }
14324                     }
14325                   else
14326                     {
14327 {
14328 return  NULL;
14329
14330 }
14331                     }
14332                 case 'n':
14333                   if (strncmp (KR_keyword, "/dev/nst115", 11) == 0)
14334                     {
14335 {
14336 return dev_storage + 155;
14337
14338 }
14339                     }
14340                   else
14341                     {
14342 {
14343 return  NULL;
14344
14345 }
14346                     }
14347                 default:
14348 {
14349 return  NULL;
14350
14351 }
14352                 }
14353             case '4':
14354               switch (KR_keyword [5])
14355                 {
14356                 case 't':
14357                   if (strncmp (KR_keyword, "/dev/ttyS14", 11) == 0)
14358                     {
14359 {
14360 return dev_storage + 828;
14361
14362 }
14363                     }
14364                   else
14365                     {
14366 {
14367 return  NULL;
14368
14369 }
14370                     }
14371                 case 'n':
14372                   if (strncmp (KR_keyword, "/dev/nst114", 11) == 0)
14373                     {
14374 {
14375 return dev_storage + 154;
14376
14377 }
14378                     }
14379                   else
14380                     {
14381 {
14382 return  NULL;
14383
14384 }
14385                     }
14386                 default:
14387 {
14388 return  NULL;
14389
14390 }
14391                 }
14392             case '3':
14393               switch (KR_keyword [5])
14394                 {
14395                 case 't':
14396                   if (strncmp (KR_keyword, "/dev/ttyS13", 11) == 0)
14397                     {
14398 {
14399 return dev_storage + 827;
14400
14401 }
14402                     }
14403                   else
14404                     {
14405 {
14406 return  NULL;
14407
14408 }
14409                     }
14410                 case 'n':
14411                   if (strncmp (KR_keyword, "/dev/nst113", 11) == 0)
14412                     {
14413 {
14414 return dev_storage + 153;
14415
14416 }
14417                     }
14418                   else
14419                     {
14420 {
14421 return  NULL;
14422
14423 }
14424                     }
14425                 default:
14426 {
14427 return  NULL;
14428
14429 }
14430                 }
14431             case '2':
14432               switch (KR_keyword [5])
14433                 {
14434                 case 't':
14435                   if (strncmp (KR_keyword, "/dev/ttyS12", 11) == 0)
14436                     {
14437 {
14438 return dev_storage + 826;
14439
14440 }
14441                     }
14442                   else
14443                     {
14444 {
14445 return  NULL;
14446
14447 }
14448                     }
14449                 case 'n':
14450                   if (strncmp (KR_keyword, "/dev/nst112", 11) == 0)
14451                     {
14452 {
14453 return dev_storage + 152;
14454
14455 }
14456                     }
14457                   else
14458                     {
14459 {
14460 return  NULL;
14461
14462 }
14463                     }
14464                 default:
14465 {
14466 return  NULL;
14467
14468 }
14469                 }
14470             case '1':
14471               switch (KR_keyword [5])
14472                 {
14473                 case 't':
14474                   if (strncmp (KR_keyword, "/dev/ttyS11", 11) == 0)
14475                     {
14476 {
14477 return dev_storage + 825;
14478
14479 }
14480                     }
14481                   else
14482                     {
14483 {
14484 return  NULL;
14485
14486 }
14487                     }
14488                 case 'n':
14489                   if (strncmp (KR_keyword, "/dev/nst111", 11) == 0)
14490                     {
14491 {
14492 return dev_storage + 151;
14493
14494 }
14495                     }
14496                   else
14497                     {
14498 {
14499 return  NULL;
14500
14501 }
14502                     }
14503                 default:
14504 {
14505 return  NULL;
14506
14507 }
14508                 }
14509             case '0':
14510               switch (KR_keyword [5])
14511                 {
14512                 case 't':
14513                   if (strncmp (KR_keyword, "/dev/ttyS10", 11) == 0)
14514                     {
14515 {
14516 return dev_storage + 824;
14517
14518 }
14519                     }
14520                   else
14521                     {
14522 {
14523 return  NULL;
14524
14525 }
14526                     }
14527                 case 'n':
14528                   if (strncmp (KR_keyword, "/dev/nst110", 11) == 0)
14529                     {
14530 {
14531 return dev_storage + 150;
14532
14533 }
14534                     }
14535                   else
14536                     {
14537 {
14538 return  NULL;
14539
14540 }
14541                     }
14542                 default:
14543 {
14544 return  NULL;
14545
14546 }
14547                 }
14548             default:
14549 {
14550 return  NULL;
14551
14552 }
14553             }
14554         case '0':
14555           switch (KR_keyword [10])
14556             {
14557             case '9':
14558               if (strncmp (KR_keyword, "/dev/nst109", 11) == 0)
14559                 {
14560 {
14561 return dev_storage + 149;
14562
14563 }
14564                 }
14565               else
14566                 {
14567 {
14568 return  NULL;
14569
14570 }
14571                 }
14572             case '8':
14573               if (strncmp (KR_keyword, "/dev/nst108", 11) == 0)
14574                 {
14575 {
14576 return dev_storage + 148;
14577
14578 }
14579                 }
14580               else
14581                 {
14582 {
14583 return  NULL;
14584
14585 }
14586                 }
14587             case '7':
14588               if (strncmp (KR_keyword, "/dev/nst107", 11) == 0)
14589                 {
14590 {
14591 return dev_storage + 147;
14592
14593 }
14594                 }
14595               else
14596                 {
14597 {
14598 return  NULL;
14599
14600 }
14601                 }
14602             case '6':
14603               if (strncmp (KR_keyword, "/dev/nst106", 11) == 0)
14604                 {
14605 {
14606 return dev_storage + 146;
14607
14608 }
14609                 }
14610               else
14611                 {
14612 {
14613 return  NULL;
14614
14615 }
14616                 }
14617             case '5':
14618               if (strncmp (KR_keyword, "/dev/nst105", 11) == 0)
14619                 {
14620 {
14621 return dev_storage + 145;
14622
14623 }
14624                 }
14625               else
14626                 {
14627 {
14628 return  NULL;
14629
14630 }
14631                 }
14632             case '4':
14633               if (strncmp (KR_keyword, "/dev/nst104", 11) == 0)
14634                 {
14635 {
14636 return dev_storage + 144;
14637
14638 }
14639                 }
14640               else
14641                 {
14642 {
14643 return  NULL;
14644
14645 }
14646                 }
14647             case '3':
14648               if (strncmp (KR_keyword, "/dev/nst103", 11) == 0)
14649                 {
14650 {
14651 return dev_storage + 143;
14652
14653 }
14654                 }
14655               else
14656                 {
14657 {
14658 return  NULL;
14659
14660 }
14661                 }
14662             case '2':
14663               if (strncmp (KR_keyword, "/dev/nst102", 11) == 0)
14664                 {
14665 {
14666 return dev_storage + 142;
14667
14668 }
14669                 }
14670               else
14671                 {
14672 {
14673 return  NULL;
14674
14675 }
14676                 }
14677             case '1':
14678               if (strncmp (KR_keyword, "/dev/nst101", 11) == 0)
14679                 {
14680 {
14681 return dev_storage + 141;
14682
14683 }
14684                 }
14685               else
14686                 {
14687 {
14688 return  NULL;
14689
14690 }
14691                 }
14692             case '0':
14693               if (strncmp (KR_keyword, "/dev/nst100", 11) == 0)
14694                 {
14695 {
14696 return dev_storage + 140;
14697
14698 }
14699                 }
14700               else
14701                 {
14702 {
14703 return  NULL;
14704
14705 }
14706                 }
14707             default:
14708 {
14709 return  NULL;
14710
14711 }
14712             }
14713         default:
14714 {
14715 return  NULL;
14716
14717 }
14718         }
14719     case 12:
14720       switch (KR_keyword [5])
14721         {
14722         case 'w':
14723           if (strncmp (KR_keyword, "/dev/windows", 12) == 0)
14724             {
14725 {
14726 return dev_storage + 832;
14727
14728 }
14729             }
14730           else
14731             {
14732 {
14733 return  NULL;
14734
14735 }
14736             }
14737         case 'u':
14738           if (strncmp (KR_keyword, "/dev/urandom", 12) == 0)
14739             {
14740 {
14741 return dev_storage + 831;
14742
14743 }
14744             }
14745           else
14746             {
14747 {
14748 return  NULL;
14749
14750 }
14751             }
14752         case 'c':
14753           if (strncmp (KR_keyword, "/dev/console", 12) == 0)
14754             {
14755 {
14756 return dev_storage + 19;
14757
14758 }
14759             }
14760           else
14761             {
14762 {
14763 return  NULL;
14764
14765 }
14766             }
14767         default:
14768 {
14769 return  NULL;
14770
14771 }
14772         }
14773     case 14:
14774           if (strncmp (KR_keyword, "/dev/clipboard", 14) == 0)
14775             {
14776 {
14777 return dev_storage + 0;
14778
14779 }
14780             }
14781           else
14782             {
14783 {
14784 return  NULL;
14785
14786 }
14787             }
14788     default:
14789 {
14790 return  NULL;
14791
14792 }
14793     }
14794 }
14795
14796
14797
14798
14799
14800
14801 void
14802 device::parse (const char *s)
14803 {
14804   size_t len = strlen (s);
14805   const device *dev = KR_find_keyword (s, len);
14806
14807   if (!dev)
14808     *this = *fs_dev;
14809   else
14810     *this = *dev;
14811 }
14812
14813 void
14814 device::init ()
14815 {
14816   /* nothing to do... yet */
14817 }
14818
14819 void
14820 device::parse (_major_t major, _minor_t minor)
14821 {
14822   _dev_t dev = FHDEV (major, minor);
14823
14824   devn = 0;
14825
14826   for (unsigned i = 0; i < (sizeof (dev_storage) / sizeof (dev_storage[0])); i++)
14827     if (dev_storage[i].devn == dev)
14828       {
14829         *this = dev_storage[i];
14830         break;
14831       }
14832
14833   if (!*this)
14834     devn = FHDEV (major, minor);
14835   return;
14836 }
14837
14838 void
14839 device::parse (_dev_t dev)
14840 {
14841   parse (_major (dev), _minor (dev));
14842 }
14843
14844 void
14845 device::tty_to_real_device ()
14846 {
14847   if (!real_tty_attached (myself))
14848     *this = myself->ctty < 0 ? dev_bad_storage : *console_dev;
14849   else
14850     parse (DEV_TTYS_MAJOR, myself->ctty);
14851 }
14852
14853
14854