They're trying to identify what skills the students DO have,not on what they don't. The handicapped student could be good at spatial relations , the "disadvantaged" could be a good leader, etc...
No, you are simply holding those people to a different standard. Bobby may be a good leader, but what if he is not good at reading. Why send people, who are not prepaired, to college? You are setting those people up for failure in the real world.
Then again, maybe I am turning into an old crotchity bastard;)
Why all this trying to get hundreds of terabytes of music on a computer? Aren't there more fascinating things than non-visual communication and data exchange?
./term , you don't dance much do you? Seriously, music is one of the best ways of expressing emotions to other people. It can make you happy, sad, pissed off simply by listening. It is a powerful thing. Its Music;)
Is this what all the fuss is about??? Sure looks like speech to me;)
/* * Copyright (C) 1999 Derek Fawcus * * This code may be used under the terms of Version 2 of the GPL, * read the file COPYING for details. * */
/* * These routines do some reordering of the supplied data before * calling engine() to do the main work. * * The reordering seems similar to that done by the initial stages of * the DES algorithm, in that it looks like it's just been done to * try and make software decoding slower. I'm not sure that it * actually adds anything to the security. * * The nature of the shuffling is that the bits of the supplied * parameter 'varient' are reorganised (and some inverted), and * the bytes of the parameter 'challenge' are reorganised. * * The reorganisation in each routine is different, and the first * (CryptKey1) does not bother of play with the 'varient' parameter. * * Since this code is only run once per disk change, I've made the * code table driven in order to improve readability. * * Since these routines are so similar to each other, one could even * abstract them all to one routine supplied a parameter determining * the nature of the reordering it has to do. */
for (i = 9; i >= 0; --i) scratch[i] = challenge[perm_challenge[i]];
engine(perm_varient[varient], scratch, key); }
/* * We use two LFSR's (seeded from some of the input data bytes) to * generate two streams of pseudo-random bits. These two bit streams * are then combined by simply adding with carry to generate a final * sequence of pseudo-random bits which is stored in the buffer that * 'output' points to the end of - len is the size of this buffer. * * The first LFSR is of degree 25, and has a polynomial of: * x^13 + x^5 + x^4 + x^1 + 1 * * The second LSFR is of degree 17, and has a (primitive) polynomial of: * x^15 + x^1 + 1 * * I don't know if these polynomials are primitive modulo 2, and thus * represent maximal-period LFSR's. * * * Note that we take the output of each LFSR from the new shifted in * bit, not the old shifted out bit. Thus for ease of use the LFSR's * are implemented in bit reversed order. * */ static void generate_bits(byte *output, int len, struct block const *s) { u32 lfsr0, lfsr1; byte carry;
/* In order to ensure that the LFSR works we need to ensure that the * initial values are non-zero. Thus when we initialise them from * the seed, we ensure that a bit is set. */ lfsr0 = (s->b[0] b[1] b[2] & ~7) b[2] & 7); lfsr1 = (s->b[3] b[4];
/* * This encryption engine implements one of 32 variations * one the same theme depending upon the choice in the * varient parameter (0 - 31). * * The algorithm itself manipulates a 40 bit input into * a 40 bit output. * The parameter 'input' is 80 bits. It consists of * the 40 bit input value that is to be encrypted followed * by a 40 bit seed value for the pseudo random number * generators. */ static void engine(int varient, byte const *input, struct block *output) { byte cse, term, index; struct block temp1; struct block temp2; byte bits[30];
int i;
/* Feed the secret into the input values such that * we alter the seed to the LFSR's used above, then * generate the bits to play with. */ for (i = 5; --i >= 0; ) temp1.b[i] = input[5 + i] ^ Secret[i] ^ Table2[i];
generate_bits(&bits[29], sizeof bits, &temp1);
/* This term is used throughout the following to * select one of 32 different variations on the * algorithm. */ cse = Varients[varient] ^ Table2[varient];
/* Now the actual blocks doing the encryption. Each * of these works on 40 bits at a time and are quite * similar. */ for (i = 5, term = 0; --i >= 0; term = input[i]) { index = bits[25 + i] ^ input[i]; index = Table1[index] ^ ~Table2[index] ^ cse;
for (i = 5, term = 0; --i >= 0; term = temp2.b[i]) { index = bits[15 + i] ^ temp2.b[i]; index = Table1[index] ^ ~Table2[index] ^ cse; index = Table2[index] ^ Table3[index] ^ term;
The "feds" were perfectly within their right to act the way that they did, and (except for the erronious inventory sheet) appear to have done nothing wrong according to the above account. I'm tired, DAMN tired, of people blaming the feds for doing their job...
How about these guys ("The Feds") sending a cease and desist order?? I mean come one, this type of grandstanding does nothing more than piss people "in the know" off. Why would they take such drastic actions without telling Ramsey they were doing something wrong, I will tell you why. Joe Luser out there wants to feel safe. If these guys can go in there and create some good PR. about "protecting Mr. Luser from the Bad Guys", Mr. Luser dosent mind sending half his paycheck to the Government. Imagine the same situation in say, um Waco,Tx. It could of been handled better, but no. They need good spin, go get those guys that have the power to do harm. The mindset today is if you have the power to do harm, someday you will do harm. Bottom line, Yet Another PR Stunt Gone Wrong. We need to get better pay for the Agents in Charge of such things. Maybe we can attract better talent than what we have.
If you really want evil, take a look at random acts of violence/vandalism, where there is absolutely no personal gain. That's what I define as 'evil'. I would say anything that causes an atificial hold on progress as harmfull. It's not as if these guys have come up with anything novel. It's not as if these guys are patenting a manufacturing process. These guys have patent the use of cookies in selling things on the web. No good can come of this, it is evil.
The Genie is out of the bottle...
on
License to Surf
·
· Score: 1
... and I doubt that "they" can put it back in. If "they" attempt to regulate or otherwise hinder the free exchange of information and ideas, we will make our own networks. As the price of the physical connections drop, we will see other networks pop up that are seperate from the Internet.
I used to run a multi-user multi-tasking operating system on my old Tandy Color Computer called OS-9. It was very cool for the late 80's. I had a c compiler and a basic programming language called Basic-09.
It also had a native windowing interface as well as Desktop Enviroment called "Multi view".
You have never really used a computer until you cobbel your own custom boot disk;) It makes a linux kernel compile look as easy as typing sys a:\ under dos.
I found it funny when RedHat went public, that little whiner who complained that they were getting rich on his code. Tsk Tsk, you gave up ownership to that code.
I can't imagine why someone would be mad because their free software was distributed far and wide. Did you just make that up?? BTW If it is GPL, they did NOT give up ownership of that code. He can sell that code as a closed app, after all he wrote it.
Yes it does. The copyright holder can do ANYTHING with GPL software he wrote. Sell it as a closed product or whatever. What you speak of is "Public Domain" software. They are not the same thing.
Granted, not "kernel" mods, but "different" -- and significantly different (IMHO) than any other Linux distro. Yet, nobody but nobody has adopted their modifications.
Um what about Mandrake,PPC Linux and MkLinux. These are all RPM based distros. I'm not a kernel geek, but I'd be willing to bet that there are kernel differences too.
Only in the fact that the precompiled default binary is not the same in every distro. It's all still Linux, but with various different modules loaded. I would only call it a fork when it is something such as PPC Linux and MkLinux.;)
It could be done. If you know of any stations that are a few hundred miles away and are on a clear channel, tune to that channel and see. I would suggest VHF, there are more VHF stations to listen for.
Allowing people to see the protocol would allow them to do stupid things like telling the Napster server they have 5 billion mp3's ready for download Sure, no one will figure out the protocol;)
Slashdot Mirror
They're trying to identify what skills the students DO have ,not on what they don't. The handicapped student could be good at spatial relations , the "disadvantaged" could be a good leader, etc...
;)
No, you are simply holding those people to a different standard. Bobby may be a good leader, but what if he is not good at reading. Why send people, who are not prepaired, to college? You are setting those people up for failure in the real world.
Then again, maybe I am turning into an old crotchity bastard
[1] Does compiling proprietary code with gcc make it GPL? How do you know which libraries are okay to link in (if any)?
Nope, ever heard of the LGPL??
[2] Does including some GPL tool with your proprietary package put the *whole* package under GPL?
Nope, just make sure the tool is a seperate program and your distro method complies with the GPL.
[3] Does using GPLed software to write *nix drivers for some piece of hardware mean that the the hardware specs/design have to be made "open" now?
Nope, see [1]
Why all this trying to get hundreds of terabytes of music on a computer? Aren't there more fascinating things than non-visual communication and data exchange?
;)
./term , you don't dance much do you? Seriously, music is one of the best ways of expressing emotions to other people. It can make you happy, sad, pissed off simply by listening. It is a powerful thing. Its Music
Is this what all the fuss is about??? Sure looks like speech to me ;)
/* In order to ensure that the LFSR works we need to ensure that the
/* Feed the secret into the input values such that
/* This term is used throughout the following to
/* Now the actual blocks doing the encryption. Each
/*
* Copyright (C) 1999 Derek Fawcus
*
* This code may be used under the terms of Version 2 of the GPL,
* read the file COPYING for details.
*
*/
/*
* These routines do some reordering of the supplied data before
* calling engine() to do the main work.
*
* The reordering seems similar to that done by the initial stages of
* the DES algorithm, in that it looks like it's just been done to
* try and make software decoding slower. I'm not sure that it
* actually adds anything to the security.
*
* The nature of the shuffling is that the bits of the supplied
* parameter 'varient' are reorganised (and some inverted), and
* the bytes of the parameter 'challenge' are reorganised.
*
* The reorganisation in each routine is different, and the first
* (CryptKey1) does not bother of play with the 'varient' parameter.
*
* Since this code is only run once per disk change, I've made the
* code table driven in order to improve readability.
*
* Since these routines are so similar to each other, one could even
* abstract them all to one routine supplied a parameter determining
* the nature of the reordering it has to do.
*/
#include "css-auth.h"
typedef unsigned long u32;
static void engine(int varient, byte const *input, struct block *output);
void CryptKey1(int varient, byte const *challenge, struct block *key)
{
static byte perm_challenge[] = {1,3,0,7,5, 2,9,6,4,8};
byte scratch[10];
int i;
for (i = 9; i >= 0; --i)
scratch[i] = challenge[perm_challenge[i]];
engine(varient, scratch, key);
}
/* This shuffles the bits in varient to make perm_varient such that
* 4 -> !3
* 3 -> 4
* varient bits: 2 -> 0 perm_varient bits
* 1 -> 2
* 0 -> !1
*/
void CryptKey2(int varient, byte const *challenge, struct block *key)
{
static byte perm_challenge[] = {6,1,9,3,8, 5,7,4,0,2};
static byte perm_varient[] = {
0x0a, 0x08, 0x0e, 0x0c, 0x0b, 0x09, 0x0f, 0x0d,
0x1a, 0x18, 0x1e, 0x1c, 0x1b, 0x19, 0x1f, 0x1d,
0x02, 0x00, 0x06, 0x04, 0x03, 0x01, 0x07, 0x05,
0x12, 0x10, 0x16, 0x14, 0x13, 0x11, 0x17, 0x15};
byte scratch[10];
int i;
for (i = 9; i >= 0; --i)
scratch[i] = challenge[perm_challenge[i]];
engine(perm_varient[varient], scratch, key);
}
/* This shuffles the bits in varient to make perm_varient such that
* 4 -> 0
* 3 -> !1
* varient bits: 2 -> !4 perm_varient bits
* 1 -> 2
* 0 -> 3
*/
void CryptBusKey(int varient, byte const *challenge, struct block *key)
{
static byte perm_challenge[] = {4,0,3,5,7, 2,8,6,1,9};
static byte perm_varient[] = {
0x12, 0x1a, 0x16, 0x1e, 0x02, 0x0a, 0x06, 0x0e,
0x10, 0x18, 0x14, 0x1c, 0x00, 0x08, 0x04, 0x0c,
0x13, 0x1b, 0x17, 0x1f, 0x03, 0x0b, 0x07, 0x0f,
0x11, 0x19, 0x15, 0x1d, 0x01, 0x09, 0x05, 0x0d};
byte scratch[10];
int i;
for (i = 9; i >= 0; --i)
scratch[i] = challenge[perm_challenge[i]];
engine(perm_varient[varient], scratch, key);
}
/*
* We use two LFSR's (seeded from some of the input data bytes) to
* generate two streams of pseudo-random bits. These two bit streams
* are then combined by simply adding with carry to generate a final
* sequence of pseudo-random bits which is stored in the buffer that
* 'output' points to the end of - len is the size of this buffer.
*
* The first LFSR is of degree 25, and has a polynomial of:
* x^13 + x^5 + x^4 + x^1 + 1
*
* The second LSFR is of degree 17, and has a (primitive) polynomial of:
* x^15 + x^1 + 1
*
* I don't know if these polynomials are primitive modulo 2, and thus
* represent maximal-period LFSR's.
*
*
* Note that we take the output of each LFSR from the new shifted in
* bit, not the old shifted out bit. Thus for ease of use the LFSR's
* are implemented in bit reversed order.
*
*/
static void generate_bits(byte *output, int len, struct block const *s)
{
u32 lfsr0, lfsr1;
byte carry;
* initial values are non-zero. Thus when we initialise them from
* the seed, we ensure that a bit is set.
*/
lfsr0 = (s->b[0] b[1] b[2] & ~7) b[2] & 7);
lfsr1 = (s->b[3] b[4];
++output;
carry = 0;
do {
int bit;
byte val;
for (bit = 0, val = 0; bit > 24) ^ (lfsr0 >> 21) ^ (lfsr0 >> 20) ^ (lfsr0 >> 12)) & 1;
lfsr0 = (lfsr0 > 16) ^ (lfsr1 >> 2)) & 1;
lfsr1 = (lfsr1 > 1) & 1)
combined = !o_lfsr1 + carry + !o_lfsr0;
carry = BIT1(combined);
val |= BIT0(combined) 0);
}
static byte Secret[];
static byte Varients[];
static byte Table0[];
static byte Table1[];
static byte Table2[];
static byte Table3[];
/*
* This encryption engine implements one of 32 variations
* one the same theme depending upon the choice in the
* varient parameter (0 - 31).
*
* The algorithm itself manipulates a 40 bit input into
* a 40 bit output.
* The parameter 'input' is 80 bits. It consists of
* the 40 bit input value that is to be encrypted followed
* by a 40 bit seed value for the pseudo random number
* generators.
*/
static void engine(int varient, byte const *input, struct block *output)
{
byte cse, term, index;
struct block temp1;
struct block temp2;
byte bits[30];
int i;
* we alter the seed to the LFSR's used above, then
* generate the bits to play with.
*/
for (i = 5; --i >= 0; )
temp1.b[i] = input[5 + i] ^ Secret[i] ^ Table2[i];
generate_bits(&bits[29], sizeof bits, &temp1);
* select one of 32 different variations on the
* algorithm.
*/
cse = Varients[varient] ^ Table2[varient];
* of these works on 40 bits at a time and are quite
* similar.
*/
for (i = 5, term = 0; --i >= 0; term = input[i]) {
index = bits[25 + i] ^ input[i];
index = Table1[index] ^ ~Table2[index] ^ cse;
temp1.b[i] = Table2[index] ^ Table3[index] ^ term;
}
temp1.b[4] ^= temp1.b[0];
for (i = 5, term = 0; --i >= 0; term = temp1.b[i]) {
index = bits[20 + i] ^ temp1.b[i];
index = Table1[index] ^ ~Table2[index] ^ cse;
temp2.b[i] = Table2[index] ^ Table3[index] ^ term;
}
temp2.b[4] ^= temp2.b[0];
for (i = 5, term = 0; --i >= 0; term = temp2.b[i]) {
index = bits[15 + i] ^ temp2.b[i];
index = Table1[index] ^ ~Table2[index] ^ cse;
index = Table2[index] ^ Table3[index] ^ term;
temp1.b[i] = Table0[index] ^ Table2[index];
}
temp1.b[4] ^= temp1.b[0];
for (i = 5, term = 0; --i >= 0; term = temp1.b[i]) {
index = bits[10 + i] ^ temp1.b[i];
index = Table1[index] ^ ~Table2[index] ^ cse;
index = Table2[index] ^ Table3[index] ^ term;
temp2.b[i] = Table0[index] ^ Table2[index];
}
temp2.b[4] ^= temp2.b[0];
for (i = 5, term = 0; --i >= 0; term = temp2.b[i]) {
index = bits[5 + i] ^ temp2.b[i];
index = Table1[index] ^ ~Table2[index] ^ cse;
temp1.b[i] = Table2[index] ^ Table3[index] ^ term;
}
temp1.b[4] ^= temp1.b[0];
for (i = 5, term = 0; --i >= 0; term = temp1.b[i]) {
index = bits[i] ^ temp1.b[i];
index = Table1[index] ^ ~Table2[index] ^ cse;
output->b[i] = Table2[index] ^ Table3[index] ^ term;
}
}
static byte Varients[] = {
0xB7, 0x74, 0x85, 0xD0, 0xCC, 0xDB, 0xCA, 0x73,
0x03, 0xFE, 0x31, 0x03, 0x52, 0xE0, 0xB7, 0x42,
0x63, 0x16, 0xF2, 0x2A, 0x79, 0x52, 0xFF, 0x1B,
0x7A, 0x11, 0xCA, 0x1A, 0x9B, 0x40, 0xAD, 0x01};
static byte Secret[] = {0x55, 0xD6, 0xC4, 0xC5, 0x28};
static byte Table0[] = {
0xB7, 0xF4, 0x82, 0x57, 0xDA, 0x4D, 0xDB, 0xE2,
0x2F, 0x52, 0x1A, 0xA8, 0x68, 0x5A, 0x8A, 0xFF,
0xFB, 0x0E, 0x6D, 0x35, 0xF7, 0x5C, 0x76, 0x12,
0xCE, 0x25, 0x79, 0x29, 0x39, 0x62, 0x08, 0x24,
0xA5, 0x85, 0x7B, 0x56, 0x01, 0x23, 0x68, 0xCF,
0x0A, 0xE2, 0x5A, 0xED, 0x3D, 0x59, 0xB0, 0xA9,
0xB0, 0x2C, 0xF2, 0xB8, 0xEF, 0x32, 0xA9, 0x40,
0x80, 0x71, 0xAF, 0x1E, 0xDE, 0x8F, 0x58, 0x88,
0xB8, 0x3A, 0xD0, 0xFC, 0xC4, 0x1E, 0xB5, 0xA0,
0xBB, 0x3B, 0x0F, 0x01, 0x7E, 0x1F, 0x9F, 0xD9,
0xAA, 0xB8, 0x3D, 0x9D, 0x74, 0x1E, 0x25, 0xDB,
0x37, 0x56, 0x8F, 0x16, 0xBA, 0x49, 0x2B, 0xAC,
0xD0, 0xBD, 0x95, 0x20, 0xBE, 0x7A, 0x28, 0xD0,
0x51, 0x64, 0x63, 0x1C, 0x7F, 0x66, 0x10, 0xBB,
0xC4, 0x56, 0x1A, 0x04, 0x6E, 0x0A, 0xEC, 0x9C,
0xD6, 0xE8, 0x9A, 0x7A, 0xCF, 0x8C, 0xDB, 0xB1,
0xEF, 0x71, 0xDE, 0x31, 0xFF, 0x54, 0x3E, 0x5E,
0x07, 0x69, 0x96, 0xB0, 0xCF, 0xDD, 0x9E, 0x47,
0xC7, 0x96, 0x8F, 0xE4, 0x2B, 0x59, 0xC6, 0xEE,
0xB9, 0x86, 0x9A, 0x64, 0x84, 0x72, 0xE2, 0x5B,
0xA2, 0x96, 0x58, 0x99, 0x50, 0x03, 0xF5, 0x38,
0x4D, 0x02, 0x7D, 0xE7, 0x7D, 0x75, 0xA7, 0xB8,
0x67, 0x87, 0x84, 0x3F, 0x1D, 0x11, 0xE5, 0xFC,
0x1E, 0xD3, 0x83, 0x16, 0xA5, 0x29, 0xF6, 0xC7,
0x15, 0x61, 0x29, 0x1A, 0x43, 0x4F, 0x9B, 0xAF,
0xC5, 0x87, 0x34, 0x6C, 0x0F, 0x3B, 0xA8, 0x1D,
0x45, 0x58, 0x25, 0xDC, 0xA8, 0xA3, 0x3B, 0xD1,
0x79, 0x1B, 0x48, 0xF2, 0xE9, 0x93, 0x1F, 0xFC,
0xDB, 0x2A, 0x90, 0xA9, 0x8A, 0x3D, 0x39, 0x18,
0xA3, 0x8E, 0x58, 0x6C, 0xE0, 0x12, 0xBB, 0x25,
0xCD, 0x71, 0x22, 0xA2, 0x64, 0xC6, 0xE7, 0xFB,
0xAD, 0x94, 0x77, 0x04, 0x9A, 0x39, 0xCF, 0x7C};
static byte Table1[] = {
0x8C, 0x47, 0xB0, 0xE1, 0xEB, 0xFC, 0xEB, 0x56,
0x10, 0xE5, 0x2C, 0x1A, 0x5D, 0xEF, 0xBE, 0x4F,
0x08, 0x75, 0x97, 0x4B, 0x0E, 0x25, 0x8E, 0x6E,
0x39, 0x5A, 0x87, 0x53, 0xC4, 0x1F, 0xF4, 0x5C,
0x4E, 0xE6, 0x99, 0x30, 0xE0, 0x42, 0x88, 0xAB,
0xE5, 0x85, 0xBC, 0x8F, 0xD8, 0x3C, 0x54, 0xC9,
0x53, 0x47, 0x18, 0xD6, 0x06, 0x5B, 0x41, 0x2C,
0x67, 0x1E, 0x41, 0x74, 0x33, 0xE2, 0xB4, 0xE0,
0x23, 0x29, 0x42, 0xEA, 0x55, 0x0F, 0x25, 0xB4,
0x24, 0x2C, 0x99, 0x13, 0xEB, 0x0A, 0x0B, 0xC9,
0xF9, 0x63, 0x67, 0x43, 0x2D, 0xC7, 0x7D, 0x07,
0x60, 0x89, 0xD1, 0xCC, 0xE7, 0x94, 0x77, 0x74,
0x9B, 0x7E, 0xD7, 0xE6, 0xFF, 0xBB, 0x68, 0x14,
0x1E, 0xA3, 0x25, 0xDE, 0x3A, 0xA3, 0x54, 0x7B,
0x87, 0x9D, 0x50, 0xCA, 0x27, 0xC3, 0xA4, 0x50,
0x91, 0x27, 0xD4, 0xB0, 0x82, 0x41, 0x97, 0x79,
0x94, 0x82, 0xAC, 0xC7, 0x8E, 0xA5, 0x4E, 0xAA,
0x78, 0x9E, 0xE0, 0x42, 0xBA, 0x28, 0xEA, 0xB7,
0x74, 0xAD, 0x35, 0xDA, 0x92, 0x60, 0x7E, 0xD2,
0x0E, 0xB9, 0x24, 0x5E, 0x39, 0x4F, 0x5E, 0x63,
0x09, 0xB5, 0xFA, 0xBF, 0xF1, 0x22, 0x55, 0x1C,
0xE2, 0x25, 0xDB, 0xC5, 0xD8, 0x50, 0x03, 0x98,
0xC4, 0xAC, 0x2E, 0x11, 0xB4, 0x38, 0x4D, 0xD0,
0xB9, 0xFC, 0x2D, 0x3C, 0x08, 0x04, 0x5A, 0xEF,
0xCE, 0x32, 0xFB, 0x4C, 0x92, 0x1E, 0x4B, 0xFB,
0x1A, 0xD0, 0xE2, 0x3E, 0xDA, 0x6E, 0x7C, 0x4D,
0x56, 0xC3, 0x3F, 0x42, 0xB1, 0x3A, 0x23, 0x4D,
0x6E, 0x84, 0x56, 0x68, 0xF4, 0x0E, 0x03, 0x64,
0xD0, 0xA9, 0x92, 0x2F, 0x8B, 0xBC, 0x39, 0x9C,
0xAC, 0x09, 0x5E, 0xEE, 0xE5, 0x97, 0xBF, 0xA5,
0xCE, 0xFA, 0x28, 0x2C, 0x6D, 0x4F, 0xEF, 0x77,
0xAA, 0x1B, 0x79, 0x8E, 0x97, 0xB4, 0xC3, 0xF4};
static byte Table2[] = {
0xB7, 0x75, 0x81, 0xD5, 0xDC, 0xCA, 0xDE, 0x66,
0x23, 0xDF, 0x15, 0x26, 0x62, 0xD1, 0x83, 0x77,
0xE3, 0x97, 0x76, 0xAF, 0xE9, 0xC3, 0x6B, 0x8E,
0xDA, 0xB0, 0x6E, 0xBF, 0x2B, 0xF1, 0x19, 0xB4,
0x95, 0x34, 0x48, 0xE4, 0x37, 0x94, 0x5D, 0x7B,
0x36, 0x5F, 0x65, 0x53, 0x07, 0xE2, 0x89, 0x11,
0x98, 0x85, 0xD9, 0x12, 0xC1, 0x9D, 0x84, 0xEC,
0xA4, 0xD4, 0x88, 0xB8, 0xFC, 0x2C, 0x79, 0x28,
0xD8, 0xDB, 0xB3, 0x1E, 0xA2, 0xF9, 0xD0, 0x44,
0xD7, 0xD6, 0x60, 0xEF, 0x14, 0xF4, 0xF6, 0x31,
0xD2, 0x41, 0x46, 0x67, 0x0A, 0xE1, 0x58, 0x27,
0x43, 0xA3, 0xF8, 0xE0, 0xC8, 0xBA, 0x5A, 0x5C,
0x80, 0x6C, 0xC6, 0xF2, 0xE8, 0xAD, 0x7D, 0x04,
0x0D, 0xB9, 0x3C, 0xC2, 0x25, 0xBD, 0x49, 0x63,
0x8C, 0x9F, 0x51, 0xCE, 0x20, 0xC5, 0xA1, 0x50,
0x92, 0x2D, 0xDD, 0xBC, 0x8D, 0x4F, 0x9A, 0x71,
0x2F, 0x30, 0x1D, 0x73, 0x39, 0x13, 0xFB, 0x1A,
0xCB, 0x24, 0x59, 0xFE, 0x05, 0x96, 0x57, 0x0F,
0x1F, 0xCF, 0x54, 0xBE, 0xF5, 0x06, 0x1B, 0xB2,
0x6D, 0xD3, 0x4D, 0x32, 0x56, 0x21, 0x33, 0x0B,
0x52, 0xE7, 0xAB, 0xEB, 0xA6, 0x74, 0x00, 0x4C,
0xB1, 0x7F, 0x82, 0x99, 0x87, 0x0E, 0x5E, 0xC0,
0x8F, 0xEE, 0x6F, 0x55, 0xF3, 0x7E, 0x08, 0x90,
0xFA, 0xB6, 0x64, 0x70, 0x47, 0x4A, 0x17, 0xA7,
0xB5, 0x40, 0x8A, 0x38, 0xE5, 0x68, 0x3E, 0x8B,
0x69, 0xAA, 0x9B, 0x42, 0xA5, 0x10, 0x01, 0x35,
0xFD, 0x61, 0x9E, 0xE6, 0x16, 0x9C, 0x86, 0xED,
0xCD, 0x2E, 0xFF, 0xC4, 0x5B, 0xA0, 0xAE, 0xCC,
0x4B, 0x3B, 0x03, 0xBB, 0x1C, 0x2A, 0xAC, 0x0C,
0x3F, 0x93, 0xC7, 0x72, 0x7A, 0x09, 0x22, 0x3D,
0x45, 0x78, 0xA9, 0xA8, 0xEA, 0xC9, 0x6A, 0xF7,
0x29, 0x91, 0xF0, 0x02, 0x18, 0x3A, 0x4E, 0x7C};
static byte Table3[] = {
0x73, 0x51, 0x95, 0xE1, 0x12, 0xE4, 0xC0, 0x58,
0xEE, 0xF2, 0x08, 0x1B, 0xA9, 0xFA, 0x98, 0x4C,
0xA7, 0x33, 0xE2, 0x1B, 0xA7, 0x6D, 0xF5, 0x30,
0x97, 0x1D, 0xF3, 0x02, 0x60, 0x5A, 0x82, 0x0F,
0x91, 0xD0, 0x9C, 0x10, 0x39, 0x7A, 0x83, 0x85,
0x3B, 0xB2, 0xB8, 0xAE, 0x0C, 0x09, 0x52, 0xEA,
0x1C, 0xE1, 0x8D, 0x66, 0x4F, 0xF3, 0xDA, 0x92,
0x29, 0xB9, 0xD5, 0xC5, 0x77, 0x47, 0x22, 0x53,
0x14, 0xF7, 0xAF, 0x22, 0x64, 0xDF, 0xC6, 0x72,
0x12, 0xF3, 0x75, 0xDA, 0xD7, 0xD7, 0xE5, 0x02,
0x9E, 0xED, 0xDA, 0xDB, 0x4C, 0x47, 0xCE, 0x91,
0x06, 0x06, 0x6D, 0x55, 0x8B, 0x19, 0xC9, 0xEF,
0x8C, 0x80, 0x1A, 0x0E, 0xEE, 0x4B, 0xAB, 0xF2,
0x08, 0x5C, 0xE9, 0x37, 0x26, 0x5E, 0x9A, 0x90,
0x00, 0xF3, 0x0D, 0xB2, 0xA6, 0xA3, 0xF7, 0x26,
0x17, 0x48, 0x88, 0xC9, 0x0E, 0x2C, 0xC9, 0x02,
0xE7, 0x18, 0x05, 0x4B, 0xF3, 0x39, 0xE1, 0x20,
0x02, 0x0D, 0x40, 0xC7, 0xCA, 0xB9, 0x48, 0x30,
0x57, 0x67, 0xCC, 0x06, 0xBF, 0xAC, 0x81, 0x08,
0x24, 0x7A, 0xD4, 0x8B, 0x19, 0x8E, 0xAC, 0xB4,
0x5A, 0x0F, 0x73, 0x13, 0xAC, 0x9E, 0xDA, 0xB6,
0xB8, 0x96, 0x5B, 0x60, 0x88, 0xE1, 0x81, 0x3F,
0x07, 0x86, 0x37, 0x2D, 0x79, 0x14, 0x52, 0xEA,
0x73, 0xDF, 0x3D, 0x09, 0xC8, 0x25, 0x48, 0xD8,
0x75, 0x60, 0x9A, 0x08, 0x27, 0x4A, 0x2C, 0xB9,
0xA8, 0x8B, 0x8A, 0x73, 0x62, 0x37, 0x16, 0x02,
0xBD, 0xC1, 0x0E, 0x56, 0x54, 0x3E, 0x14, 0x5F,
0x8C, 0x8F, 0x6E, 0x75, 0x1C, 0x07, 0x39, 0x7B,
0x4B, 0xDB, 0xD3, 0x4B, 0x1E, 0xC8, 0x7E, 0xFE,
0x3E, 0x72, 0x16, 0x83, 0x7D, 0xEE, 0xF5, 0xCA,
0xC5, 0x18, 0xF9, 0xD8, 0x68, 0xAB, 0x38, 0x85,
0xA8, 0xF0, 0xA1, 0x73, 0x9F, 0x5D, 0x19, 0x0B,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x33, 0x72, 0x39, 0x25, 0x67, 0x26, 0x6D, 0x71,
0x36, 0x77, 0x3C, 0x20, 0x62, 0x23, 0x68, 0x74,
0xC3, 0x82, 0xC9, 0x15, 0x57, 0x16, 0x5D, 0x81};
An open-source DVD player means that a player that *copies* DVD's is trivial. This is what the MPAA doesn't want.
So, I can copy CDs and that market is doing just fine. I should be able to copy my DVDs. After all, how will I make a backup??
Was this not posted 6 months ago???
The "feds" were perfectly within their right to act the way that they did, and (except for the erronious inventory sheet) appear to have done nothing wrong according to the above account. I'm tired, DAMN tired, of people blaming the feds for doing their job...
How about these guys ("The Feds") sending a cease and desist order?? I mean come one, this type of grandstanding does nothing more than piss people "in the know" off. Why would they take such drastic actions without telling Ramsey they were doing something wrong, I will tell you why. Joe Luser out there wants to feel safe. If these guys can go in there and create some good PR. about "protecting Mr. Luser from the Bad Guys", Mr. Luser dosent mind sending half his paycheck to the Government. Imagine the same situation in say, um Waco,Tx. It could of been handled better, but no. They need good spin, go get those guys that have the power to do harm. The mindset today is if you have the power to do harm, someday you will do harm. Bottom line, Yet Another PR Stunt Gone Wrong. We need to get better pay for the Agents in Charge of such things. Maybe we can attract better talent than what we have.
Especially IE 5.0..Opera is significantly slower.
That is because IE 5 caches EVERYTHING. It's a bug, not a feature.
If you really want evil, take a look at random acts of violence/vandalism, where there is absolutely no personal gain. That's what I define as 'evil'. I would say anything that causes an atificial hold on progress as harmfull. It's not as if these guys have come up with anything novel. It's not as if these guys are patenting a manufacturing process. These guys have patent the use of cookies in selling things on the web. No good can come of this, it is evil.
If you hate it so much, leave. God, some people are like sharks. If they quit bitching, they die!
I think its dead, Jim.
Here is a better article
;)
I really like the part about Linux being faster than NT
There is also one in Win98. I don't think I would have wanted my name on that POS ;)
-----BEGIN PGP MESSAGE-----
t QPv8r1SVhyid6c7E D Sq7J029x+cRLgrTb L VD1vuXRzy9M8ROMD C bpC7BYOpQTRMCNcE W MurkHeg2O2nvxpIi v 2YHDz+nde8UwR2Fs p wl4t5H1hUXdaz3fS W ntlc5txkYvu8LeBX
Version: GnuPG v1.0.0 (GNU/Linux)
Comment: Made with Geheimnis
hQEOA9DF0EXsPZ32EAQAgZrCGcItAhToQOWhcl8Kb+3dH+7
AHLp/RhNQYiVWz16ArPiAdcrlklVSPVzckcJvlLq3XygFAe
7SaLG53CXhpIYSfz6MsKRzWfm8rr1c32haMNWSVJ6zR9NNJ
/0Vdd88Lr53tE5ZLQBggBl64fXRRTXGvwar8gAtUSj3DlCe
YCwbO6yj75atP7e1l33L7C1tX6/23SKPH5Glzhqy1YEP19U
k4BZfdpHGYZUOI32BxSe15OFKAJwZGjZbQYYpSEh0+UWyXs
XluEo9kLV+LzfgogD9M1pxoRxkqTg9AnX7AaHoTtC/j69dq
ge0J8beu7JEdkas3nnVjqHXWW4aNmA3tL7PDWv3l9i8fFTI
EEpGHiGLr7epf493tB0=
=FIrG
-----END PGP MESSAGE-----
... and I doubt that "they" can put it back in. If "they" attempt to regulate or otherwise hinder the free exchange of information and ideas, we will make our own networks. As the price of the physical connections drop, we will see other networks pop up that are seperate from the Internet.
Forgive me, but do you really mean the Win98 machines suffer the 'Blue Screen of Death' under Linux?
;)
Don't say it can't happen
http://windowssucks.com/oops.jpg
I used to run a multi-user multi-tasking operating system on my old Tandy Color Computer called OS-9. It was very cool for the late 80's. I had a c compiler and a basic programming language called Basic-09.
;) It makes a linux kernel compile look as easy as typing sys a:\ under dos.
It also had a native windowing interface as well as Desktop Enviroment called "Multi view".
You have never really used a computer until you cobbel your own custom boot disk
I found it funny when RedHat went public, that little whiner who complained that they were getting rich on his code. Tsk Tsk, you gave up ownership to that code.
I can't imagine why someone would be mad because their free software was distributed far and wide. Did you just make that up?? BTW If it is GPL, they did NOT give up ownership of that code. He can sell that code as a closed app, after all he wrote it.
Yes it does. The copyright holder can do ANYTHING with GPL software he wrote. Sell it as a closed product or whatever. What you speak of is "Public Domain" software. They are not the same thing.
Granted, not "kernel" mods, but "different" -- and significantly different (IMHO) than any other Linux distro. Yet, nobody but nobody has adopted their modifications.
,PPC Linux and MkLinux. These are all RPM based distros.
;)
Um what about Mandrake
I'm not a kernel geek, but I'd be willing to bet that there are kernel differences too.
Only in the fact that the precompiled default binary is not the same in every distro. It's all still Linux, but with various different modules loaded. I would only call it a fork when it is something such as PPC Linux and MkLinux.
Well, I don't have SSB, but I'm to give it my best on FM anyway. 50 Watts on a J-pole might give some intesting results, you never know.
It could be done. If you know of any stations that are a few hundred miles away and are on a clear channel, tune to that channel and see. I would suggest VHF, there are more VHF stations to listen for.
Anyone going to be on 2m or 70cm tonight??? I know I will :)
KE4PJW
Allowing people to see the protocol would allow them to do stupid things like telling the Napster server they have 5 billion mp3's ready for download ;)
Sure, no one will figure out the protocol
Last time I checked, Netcraft didn't use Apache. But I have not checked in some time.