Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon. Entire thread

SectripCUDA

Name: !!FelMzE51EM/CUDA 2010-06-05 20:17

is comin

Name: Anonymous 2010-06-07 21:32

in certain cases
All of which are videogame related. Back to /v/, please.

Name: Anonymous 2010-06-07 21:57

>>79
OpenCL?

>>81
http://www.nvidia.com/object/cuda_app_tesla.html

Name: Anonymous 2010-06-07 22:14

>>82
>>79
OpenCL?
This obtuseness, is this deliberate?

Name: Anonymous 2010-06-08 12:58

It seems that's the tripcode procedure uses only the first 96-bits of the SHA-1.

Name: Anonymous 2010-06-08 13:10

>>84
The algorithm is well-known, dude. Here, have Xarn's code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/sha.h>

const unsigned char salt[] = {
0x15,0x6e,0x88,0xe4,0x4b,0x37,0xd7,0x5a,0xf6,0x25,0x5e,0x84,0x25,0x29,0xeb,
0x47,0x6f,0xa1,0xc3,0x7e,0xe3,0x21,0xf1,0x88,0xd0,0x50,0x74,0x5d,0x4e,0x7e,
0xf6,0x5b,0x9a,0xf6,0x20,0x82,0xaf,0x08,0x24,0x64,0x35,0x51,0x67,0xed,0x4f,
0xb8,0x29,0x6a,0x0b,0xee,0xfc,0x16,0x20,0x3a,0x86,0x18,0x57,0x53,0x5a,0x2a,
0xe8,0xec,0x85,0xc7,0xf3,0x16,0x63,0x1e,0xad,0x2a,0xc6,0x1e,0x48,0x0f,0x1c,
0x02,0xcf,0x7a,0xf4,0xd3,0x4c,0x43,0xdf,0x12,0xcd,0xd2,0xc5,0x0f,0xb6,0x62,
0x7c,0x71,0x6b,0x78,0xd7,0x6b,0x7e,0xe6,0xf7,0xc4,0xd4,0x01,0x53,0x6d,0x6b,
0x92,0x77,0xed,0x74,0x44,0x85,0x45,0x35,0x2b,0xe3,0x89,0xea,0x09,0x9d,0x30,
0xcb,0x35,0x55,0x0f,0x24,0x86,0x51,0x99,0x1b,0xb7,0x21,0xe1,0x9e,0x3f,0x9c,
0x92,0x76,0xd9,0xa8,0x3b,0xbf,0xc2,0x38,0x57,0xfc,0x78,0xd2,0x8a,0xd4,0x5b,
0xb6,0x8b,0x69,0xa3,0x38,0x45,0xe0,0x2f,0x45,0xf8,0xca,0x10,0x0a,0xbd,0xcb,
0x80,0xa8,0x3e,0x0a,0x26,0x07,0xb3,0x73,0xe1,0x77,0x7c,0x64,0xe9,0x40,0xb6,
0x04,0x6d,0x84,0x53,0xcd,0xcf,0x8a,0x09,0xc9,0x30,0xe0,0x9f,0xc7,0x30,0x34,
0xda,0x0a,0x55,0x1e,0xec,0x32,0xde,0xcc,0x7b,0x85,0x7e,0x32,0xbc,0xe6,0x01,
0xbe,0x8d,0x24,0x0a,0xc9,0x3b,0x07,0x90,0xd4,0x44,0x16,0x8d,0x58,0x7d,0x2c,
0xad,0x6c,0xf8,0x32,0x95,0xd1,0x70,0x39,0x5e,0xb4,0x61,0x82,0x78,0xa3,0xb3,
0xf4,0x79,0xf5,0x59,0x72,0x6e,0xef,0xc6,0x5d,0xc4,0x2e,0x7c,0x54,0x39,0x76,
0xd1,0x42,0x13,0xf5,0xea,0xf9,0x40,0xb9,0xd6,0x88,0x5d,0x60,0x88,0x81,0x90,
0x5d,0x03,0x2a,0x04,0x1f,0x91,0x77,0x8f,0x3f,0xb2,0xe1,0x16,0x00,0xe1,0xf6,
0x1f,0xd5,0x98,0x8a,0x64,0xc9,0x59,0x3a,0xca,0xdf,0xde,0xc7,0x31,0x67,0xa9,
0x2b,0xa2,0xc9,0x69,0x40,0x79,0x19,0xd2,0x24,0xe7,0xa6,0x40,0x50,0xb8,0xe0,
0x64,0x1d,0xbd,0xab,0x1f,0x02,0x97,0xed,0x4a,0xd0,0x95,0x90,0xd1,0x22,0x39,
0x2e,0xb7,0x63,0x83,0x26,0x59,0x51,0x35,0xfc,0x2c,0x1f,0xfa,0x0a,0x88,0xb1,
0xf5,0xee,0xbe,0xdd,0xcd,0x39,0x3e,0x4e,0x81,0x8b,0x51,0x96,0xb0,0xc5,0x9c,
0x25,0x47,0xfb,0xac,0xbf,0x6d,0xa6,0xcc,0x51,0x3a,0xda,0xb4,0x00,0x04,0x01,
0x3d,0x0d,0x2b,0x4e,0x5b,0x2d,0x14,0x4c,0xe2,0xc2,0x6d,0xef,0x45,0xa4,0xd9,
0xbc,0xf4,0x5b,0xa1,0x07,0xd1,0x12,0xd6,0xb4,0xf5,0x50,0x3e,0xb5,0x18,0x96,
0x7c,0xdd,0xd7,0x3f,0xed,0x5b,0x6c,0xc4,0xbd,0x7b,0x12,0x9a,0x70,0x62,0xcc,
0xc5,0x1f,0xdb,0x98,0xee,0x40,0xe7,0xb0,0x20,0x40,0x5f,0x9b,0x3e,0x38,0x62,
0x7f,0x93,0x3f,0x38,0xe2,0x7a,0x27,0xfe,0xfa,0xab,0x42,0x43,0x1c
};

const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef"
                  "ghijklmnopqrstuvwxyz0123456789+/";

int main(int argc, char **argv) {
    char sectrip[16];
    unsigned char *capsal, *sectrip_bin;
    int s, i;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s capcode\n", argv[0]);
        return 1;
    }

    s = strlen(argv[1]);

    capsal = malloc((s + 448) * sizeof(unsigned char));
    memcpy(capsal, argv[1], s);
    memcpy(capsal + s, salt, 448);

    sectrip_bin = SHA1(capsal, s + 448, NULL);

    for (i = 0; i < 4; ++i) {
        sectrip[i * 4]     = b64[sectrip_bin[i * 3] >> 2];
        sectrip[i * 4 + 1] = b64[((sectrip_bin[i * 3] & 3) << 4) |
                                  (sectrip_bin[i * 3 + 1] >> 4)];
        sectrip[i * 4 + 2] = b64[((sectrip_bin[i * 3 + 1] & 15) << 2) |
                                  (sectrip_bin[i * 3 + 2] >> 6)];
        sectrip[i * 4 + 3] = b64[sectrip_bin[i * 3 + 2] & 63];
    }

    sectrip[15] = 0;
    printf("%s\n", sectrip);

    return 0;
}

Name: Anonymous 2010-06-08 14:43

>86
that's pretty. unlike these jews.
jews[0] = cb64[x0>>26];
jews[1] = cb64[(((x0>>24) & 0x03) << 4) | (((x0>>16) & 0xf0) >> 4)];
jews[2] = cb64[(((x0>>16) & 0x0f) << 2) | (((x0>>8) & 0xc0) >> 6)];
jews[3] = cb64[(x0>>8) & 0x3f];
jews[4] = cb64[(x0 & 0xff)>>2];
jews[5] = cb64[(((x0 & 0x03) << 4) | (((x1>>24) & 0xff) >> 4))];
jews[6] = cb64[((((x1>>24) & 0x0f) << 2) | (((x1>>16) & 0xc0) >> 6))];
jews[7] = cb64[(x1>>16) & 0x3f];
jews[8] = cb64[((x1>>8)&0xff)>>2];
jews[9] = cb64[((((x1>>8) & 0x03) << 4) | ((x1 & 0xf0) >> 4))];
jews[10] = cb64[(((x1 & 0x0f) << 2) | (((x2>>24) & 0xc0) >> 6))];
jews[11] = cb64[((x2>>24) & 0x3f)];
jews[12] = cb64[((x2>>16) & 0xff)>>2];
jews[13] = cb64[((((x2>>16) & 0x03) << 4) | (((x2>>8) & 0xf0) >> 4))];
jews[14] = cb64[((((x2>>8) & 0x0f) << 2) | ((x2 & 0xc0) >> 6))];
jews[15] = 0;

Name: Anonymous 2010-06-08 15:48

>>86
That's basically the same thing, except you're dealing with a manually funrolled loop and a wider data type. If it's bug-free and the compiler is kept dumb, yours is probably very slightly faster, but the difference will be too minute to notice even on omg-optimized tripfinders.

Name: !!SALTSY4u1+6hA15 2010-06-08 16:48

what

Name: Anonymous 2010-06-08 23:41

>>88
Does this really have to happen in every one of these threads? Go sagetest in the dead threads on the last few pages, if you really think local tripcoders are voodoo that cannot be trusted and Shiitchan is the only source of truth.

Name: Anonymous 2010-06-09 4:22

class uint32 {
  unsigned int x;
public:
  unsigned int uint() { return x; }
  inline uint32() { }
  inline uint32(unsigned int u) { x = u; }
  inline uint32(const uint32 &a) { x = a.x; }
  friend inline uint32 operator+(uint32 a,uint32 b) { return a.x + b.x; }
  friend inline uint32 operator|(uint32 a,uint32 b) { return a.x | b.x; }
  friend inline uint32 operator&(uint32 a,uint32 b) { return a.x & b.x; }
  friend inline uint32 operator^(uint32 a,uint32 b) { return a.x ^ b.x; }
  friend inline uint32 andnot(uint32 a,uint32 b) { return a.x & ~b.x; }
  friend inline uint32 rotate1(uint32 a) { return (a.x << 1) | (a.x >> 31); }
  friend inline uint32 rotate5(uint32 a) { return (a.x << 5) | (a.x >> 27); }
  friend inline uint32 rotate30(uint32 a) { return (a.x << 30) | (a.x >> 2); }
  friend ostream& operator<<(ostream& o,const uint32& u) {
    o << hex << setw(2) << setfill('0') << ((u.x >> 24) & 255);
    o << hex << setw(2) << setfill('0') << ((u.x >> 16) & 255);
    o << hex << setw(2) << setfill('0') << ((u.x >> 8) & 255);
    o << hex << setw(2) << setfill('0') << ((u.x) & 255);
    return o;
  }
} ;

Name: Anonymous 2010-06-09 4:48

class hash {
  uint32 state[5];
public:
  hash() { }
  hash(const hash &x) {
    state[0] = x.state[0];
    state[1] = x.state[1];
    state[2] = x.state[2];
    state[3] = x.state[3];
    state[4] = x.state[4];
  }
  hash(const unsigned int x[5]) {
    state[0] = x[0];
    state[1] = x[1];
    state[2] = x[2];
    state[3] = x[3];
    state[4] = x[4];
  }
  void init()
  {
    state[0] = 0x67452301;
    state[1] = 0xefcdab89;
    state[2] = 0x98badcfe;
    state[3] = 0x10325476;
    state[4] = 0xc3d2e1f0;
  }
  friend ostream& operator<<(ostream& o,const hash& h) {
    o << h.state[0];
    o << h.state[1];
    o << h.state[2];
    o << h.state[3];
    o << h.state[4];
    return o;
  }

Name: Anonymous 2010-06-09 4:48

  void update(const unsigned int *in,unsigned long long inblocks) {
    uint32 a = state[0];
    uint32 b = state[1];
    uint32 c = state[2];
    uint32 d = state[3];
    uint32 e = state[4];
    uint32 f;
    uint32 x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15;
 
    while (inblocks > 0) {
      x0 = in[0];
      f = (c & b) | andnot(d,b);
      e = rotate5(a) + f + e + 0x5a827999 + x0;
      b = rotate30(b);
      x1 = in[1];
      f = (b & a) | andnot(c,a);
      d = rotate5(e) + f + d + 0x5a827999 + x1;
      a = rotate30(a);
      x2 = in[2];
      f = (a & e) | andnot(b,e);
      c = rotate5(d) + f + c + 0x5a827999 + x2;
      e = rotate30(e);
      x3 = in[3];
      f = (e & d) | andnot(a,d);
      b = rotate5(c) + f + b + 0x5a827999 + x3;
      d = rotate30(d);
      x4 = in[4];
      f = (d & c) | andnot(e,c);
      a = rotate5(b) + f + a + 0x5a827999 + x4;
      c = rotate30(c);
      x5 = in[5];
      f = (c & b) | andnot(d,b);
      e = rotate5(a) + f + e + 0x5a827999 + x5;
      b = rotate30(b);
      x6 = in[6];
      f = (b & a) | andnot(c,a);
      d = rotate5(e) + f + d + 0x5a827999 + x6;
      a = rotate30(a);
      x7 = in[7];
      f = (a & e) | andnot(b,e);
      c = rotate5(d) + f + c + 0x5a827999 + x7;
      e = rotate30(e);
      x8 = in[8];
      f = (e & d) | andnot(a,d);
      b = rotate5(c) + f + b + 0x5a827999 + x8;
      d = rotate30(d);
      x9 = in[9];
      f = (d & c) | andnot(e,c);
      a = rotate5(b) + f + a + 0x5a827999 + x9;
      c = rotate30(c);
      x10 = in[10];
      f = (c & b) | andnot(d,b);
      e = rotate5(a) + f + e + 0x5a827999 + x10;
      b = rotate30(b);
      x11 = in[11];
      f = (b & a) | andnot(c,a);
      d = rotate5(e) + f + d + 0x5a827999 + x11;
      a = rotate30(a);
      x12 = in[12];
      f = (a & e) | andnot(b,e);
      c = rotate5(d) + f + c + 0x5a827999 + x12;
      e = rotate30(e);
      x13 = in[13];
      f = (e & d) | andnot(a,d);
      b = rotate5(c) + f + b + 0x5a827999 + x13;
      d = rotate30(d);
      x14 = in[14];
      f = (d & c) | andnot(e,c);
      a = rotate5(b) + f + a + 0x5a827999 + x14;
      c = rotate30(c);
      x15 = in[15];
      f = (c & b) | andnot(d,b);
      e = rotate5(a) + f + e + 0x5a827999 + x15;
      b = rotate30(b);

Name: Anonymous 2010-06-09 4:52

      x0 = rotate1(x13 ^ x8 ^ x2 ^ x0);
      f = (b & a) | andnot(c,a);
      d = rotate5(e) + f + d + 0x5a827999 + x0;
      a = rotate30(a);
      x1 = rotate1(x14 ^ x9 ^ x3 ^ x1);
      f = (a & e) | andnot(b,e);
      c = rotate5(d) + f + c + 0x5a827999 + x1;
      e = rotate30(e);
      x2 = rotate1(x15 ^ x10 ^ x4 ^ x2);
      f = (e & d) | andnot(a,d);
      b = rotate5(c) + f + b + 0x5a827999 + x2;
      d = rotate30(d);
      x3 = rotate1(x0 ^ x11 ^ x5 ^ x3);
      f = (d & c) | andnot(e,c);
      a = rotate5(b) + f + a + 0x5a827999 + x3;
      c = rotate30(c);
      x4 = rotate1(x1 ^ x12 ^ x6 ^ x4);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0x6ed9eba1 + x4;
      b = rotate30(b);
      x5 = rotate1(x2 ^ x13 ^ x7 ^ x5);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0x6ed9eba1 + x5;
      a = rotate30(a);
      x6 = rotate1(x3 ^ x14 ^ x8 ^ x6);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0x6ed9eba1 + x6;
      e = rotate30(e);
      x7 = rotate1(x4 ^ x15 ^ x9 ^ x7);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0x6ed9eba1 + x7;
      d = rotate30(d);
      x8 = rotate1(x5 ^ x0 ^ x10 ^ x8);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0x6ed9eba1 + x8;
      c = rotate30(c);
      x9 = rotate1(x6 ^ x1 ^ x11 ^ x9);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0x6ed9eba1 + x9;
      b = rotate30(b);
      x10 = rotate1(x7 ^ x2 ^ x12 ^ x10);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0x6ed9eba1 + x10;
      a = rotate30(a);
      x11 = rotate1(x8 ^ x3 ^ x13 ^ x11);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0x6ed9eba1 + x11;
      e = rotate30(e);
      x12 = rotate1(x9 ^ x4 ^ x14 ^ x12);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0x6ed9eba1 + x12;
      d = rotate30(d);
      x13 = rotate1(x10 ^ x5 ^ x15 ^ x13);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0x6ed9eba1 + x13;
      c = rotate30(c);
      x14 = rotate1(x11 ^ x6 ^ x0 ^ x14);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0x6ed9eba1 + x14;
      b = rotate30(b);
      x15 = rotate1(x12 ^ x7 ^ x1 ^ x15);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0x6ed9eba1 + x15;
      a = rotate30(a);
      x0 = rotate1(x13 ^ x8 ^ x2 ^ x0);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0x6ed9eba1 + x0;
      e = rotate30(e);
      x1 = rotate1(x14 ^ x9 ^ x3 ^ x1);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0x6ed9eba1 + x1;
      d = rotate30(d);
      x2 = rotate1(x15 ^ x10 ^ x4 ^ x2);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0x6ed9eba1 + x2;
      c = rotate30(c);
      x3 = rotate1(x0 ^ x11 ^ x5 ^ x3);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0x6ed9eba1 + x3;
      b = rotate30(b);
      x4 = rotate1(x1 ^ x12 ^ x6 ^ x4);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0x6ed9eba1 + x4;
      a = rotate30(a);
      x5 = rotate1(x2 ^ x13 ^ x7 ^ x5);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0x6ed9eba1 + x5;
      e = rotate30(e);
      x6 = rotate1(x3 ^ x14 ^ x8 ^ x6);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0x6ed9eba1 + x6;
      d = rotate30(d);
      x7 = rotate1(x4 ^ x15 ^ x9 ^ x7);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0x6ed9eba1 + x7;
      c = rotate30(c);
      x8 = rotate1(x5 ^ x0 ^ x10 ^ x8);
      f = (b & c) | (b & d) | (c & d);
      e = rotate5(a) + f + e + 0x8f1bbcdc + x8;
      b = rotate30(b);
      x9 = rotate1(x6 ^ x1 ^ x11 ^ x9);
      f = (a & b) | (a & c) | (b & c);
      d = rotate5(e) + f + d + 0x8f1bbcdc + x9;
      a = rotate30(a);
      x10 = rotate1(x7 ^ x2 ^ x12 ^ x10);
      f = (e & a) | (e & b) | (a & b);
      c = rotate5(d) + f + c + 0x8f1bbcdc + x10;
      e = rotate30(e);
      x11 = rotate1(x8 ^ x3 ^ x13 ^ x11);
      f = (d & e) | (d & a) | (e & a);
      b = rotate5(c) + f + b + 0x8f1bbcdc + x11;
      d = rotate30(d);
      x12 = rotate1(x9 ^ x4 ^ x14 ^ x12);
      f = (c & d) | (c & e) | (d & e);
      a = rotate5(b) + f + a + 0x8f1bbcdc + x12;
      c = rotate30(c);
      x13 = rotate1(x10 ^ x5 ^ x15 ^ x13);
      f = (b & c) | (b & d) | (c & d);
      e = rotate5(a) + f + e + 0x8f1bbcdc + x13;
      b = rotate30(b);
      x14 = rotate1(x11 ^ x6 ^ x0 ^ x14);
      f = (a & b) | (a & c) | (b & c);
      d = rotate5(e) + f + d + 0x8f1bbcdc + x14;
      a = rotate30(a);
      x15 = rotate1(x12 ^ x7 ^ x1 ^ x15);
      f = (e & a) | (e & b) | (a & b);
      c = rotate5(d) + f + c + 0x8f1bbcdc + x15;
      e = rotate30(e);
      x0 = rotate1(x13 ^ x8 ^ x2 ^ x0);
      f = (d & e) | (d & a) | (e & a);
      b = rotate5(c) + f + b + 0x8f1bbcdc + x0;
      d = rotate30(d);
      x1 = rotate1(x14 ^ x9 ^ x3 ^ x1);
      f = (c & d) | (c & e) | (d & e);
      a = rotate5(b) + f + a + 0x8f1bbcdc + x1;
      c = rotate30(c);
      x2 = rotate1(x15 ^ x10 ^ x4 ^ x2);
      f = (b & c) | (b & d) | (c & d);
      e = rotate5(a) + f + e + 0x8f1bbcdc + x2;
      b = rotate30(b);
      x3 = rotate1(x0 ^ x11 ^ x5 ^ x3);
      f = (a & b) | (a & c) | (b & c);
      d = rotate5(e) + f + d + 0x8f1bbcdc + x3;
      a = rotate30(a);
      x4 = rotate1(x1 ^ x12 ^ x6 ^ x4);
      f = (e & a) | (e & b) | (a & b);
      c = rotate5(d) + f + c + 0x8f1bbcdc + x4;
      e = rotate30(e);
      x5 = rotate1(x2 ^ x13 ^ x7 ^ x5);
      f = (d & e) | (d & a) | (e & a);
      b = rotate5(c) + f + b + 0x8f1bbcdc + x5;
      d = rotate30(d);
      x6 = rotate1(x3 ^ x14 ^ x8 ^ x6);
      f = (c & d) | (c & e) | (d & e);
      a = rotate5(b) + f + a + 0x8f1bbcdc + x6;
      c = rotate30(c);
      x7 = rotate1(x4 ^ x15 ^ x9 ^ x7);
      f = (b & c) | (b & d) | (c & d);
      e = rotate5(a) + f + e + 0x8f1bbcdc + x7;
      b = rotate30(b);
      x8 = rotate1(x5 ^ x0 ^ x10 ^ x8);
      f = (a & b) | (a & c) | (b & c);
      d = rotate5(e) + f + d + 0x8f1bbcdc + x8;
      a = rotate30(a);
      x9 = rotate1(x6 ^ x1 ^ x11 ^ x9);
      f = (e & a) | (e & b) | (a & b);
      c = rotate5(d) + f + c + 0x8f1bbcdc + x9;
      e = rotate30(e);
      x10 = rotate1(x7 ^ x2 ^ x12 ^ x10);
      f = (d & e) | (d & a) | (e & a);
      b = rotate5(c) + f + b + 0x8f1bbcdc + x10;
      d = rotate30(d);
      x11 = rotate1(x8 ^ x3 ^ x13 ^ x11);
      f = (c & d) | (c & e) | (d & e);
      a = rotate5(b) + f + a + 0x8f1bbcdc + x11;
      c = rotate30(c);
      x12 = rotate1(x9 ^ x4 ^ x14 ^ x12);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0xca62c1d6 + x12;
      b = rotate30(b);
      x13 = rotate1(x10 ^ x5 ^ x15 ^ x13);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0xca62c1d6 + x13;
      a = rotate30(a);
      x14 = rotate1(x11 ^ x6 ^ x0 ^ x14);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0xca62c1d6 + x14;
      e = rotate30(e);
      x15 = rotate1(x12 ^ x7 ^ x1 ^ x15);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0xca62c1d6 + x15;
      d = rotate30(d);
      x0 = rotate1(x13 ^ x8 ^ x2 ^ x0);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0xca62c1d6 + x0;
      c = rotate30(c);
      x1 = rotate1(x14 ^ x9 ^ x3 ^ x1);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0xca62c1d6 + x1;
      b = rotate30(b);
      x2 = rotate1(x15 ^ x10 ^ x4 ^ x2);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0xca62c1d6 + x2;
      a = rotate30(a);
      x3 = rotate1(x0 ^ x11 ^ x5 ^ x3);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0xca62c1d6 + x3;
      e = rotate30(e);
      x4 = rotate1(x1 ^ x12 ^ x6 ^ x4);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0xca62c1d6 + x4;
      d = rotate30(d);
      x5 = rotate1(x2 ^ x13 ^ x7 ^ x5);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0xca62c1d6 + x5;
      c = rotate30(c);
      x6 = rotate1(x3 ^ x14 ^ x8 ^ x6);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0xca62c1d6 + x6;
      b = rotate30(b);
      x7 = rotate1(x4 ^ x15 ^ x9 ^ x7);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0xca62c1d6 + x7;
      a = rotate30(a);
      x8 = rotate1(x5 ^ x0 ^ x10 ^ x8);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0xca62c1d6 + x8;
      e = rotate30(e);
      x9 = rotate1(x6 ^ x1 ^ x11 ^ x9);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0xca62c1d6 + x9;
      d = rotate30(d);
      x10 = rotate1(x7 ^ x2 ^ x12 ^ x10);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0xca62c1d6 + x10;
      c = rotate30(c);
      x11 = rotate1(x8 ^ x3 ^ x13 ^ x11);
      f = b ^ c ^ d;
      e = rotate5(a) + f + e + 0xca62c1d6 + x11;
      b = rotate30(b);
      x12 = rotate1(x9 ^ x4 ^ x14 ^ x12);
      f = a ^ b ^ c;
      d = rotate5(e) + f + d + 0xca62c1d6 + x12;
      a = rotate30(a);
      x13 = rotate1(x10 ^ x5 ^ x15 ^ x13);
      f = e ^ a ^ b;
      c = rotate5(d) + f + c + 0xca62c1d6 + x13;
      e = rotate30(e);
      x14 = rotate1(x11 ^ x6 ^ x0 ^ x14);
      f = d ^ e ^ a;
      b = rotate5(c) + f + b + 0xca62c1d6 + x14;
      d = rotate30(d);
      x15 = rotate1(x12 ^ x7 ^ x1 ^ x15);
      f = c ^ d ^ e;
      a = rotate5(b) + f + a + 0xca62c1d6 + x15;
      c = rotate30(c);
 
      a = a + state[0];
      b = b + state[1];
      c = c + state[2];
      d = d + state[3];
      e = e + state[4];
      state[0] = a;
      state[1] = b;
      state[2] = c;
      state[3] = d;
      state[4] = e;
 
      --inblocks;
      in += 16;
    }
  }
} ;

Name: Anonymous 2010-06-09 6:10

>>81
So are you insinuating that all the ALUs in GPUs are dedicated to complex operations, and so forth can't be used for general purpose computing?

Name: Anonymous 2010-06-09 8:12

>>90-93
Too bad it's in Sepples, so nobody's ever going to use it.

Name: Anonymous 2010-06-09 19:04

whats the salt for imageboards?

Name: Anonymous 2010-06-09 19:06

>>96
nah mate its well seasoned already

Name: Anonymous 2010-06-09 20:09

>>97 lol
>>96 it's generated by openssl rand 448 so you have to brute force 256[sup]448 possibilites, this number being quite hueg

Name: Anonymous 2010-06-09 20:56

>>98
lol how the hell did they find the salt for the textboards then huh? thats right, now do the same thing on the imageboards.

Name: Anonymous 2010-06-09 21:02

>>99
mrvacbob fucking posted it that's how

Name: Anonymous 2010-06-09 21:05

>>99
someone already got  the salt due to a server misconfiguration that was fixed pretty quickly, but he's being a fucking cunt and not sharing.

Name: Anonymous 2010-06-09 21:41

>>96,98,101
Who gives a fuck about the imageboards, anyway? Maybe you should be asking for the salt over there.

Name: >>102 2010-06-09 21:53

When I said >>98 I obviously meant >>99.
Speaking of >>99, get fucked, you entitled little shit.

Name: Anonymous 2010-06-09 23:22

>>42
I'm a little surprised no FPGA groups joined this competition, they could've won very easily.

Name: Anonymous 2010-06-09 23:46

>>104
Don't be too surprised.  The contest didn't get much too publicity, it ended less than a week after it was announced, it was originally aimed at ruby developers, and so forth.

Name: Anonymous 2010-06-10 4:51

>>98

Ok, thanks.

Name: Anonymous 2010-06-10 9:05

Also >>99 is an asshole.

Name: >>99 2010-06-10 10:37

Holy shit, you were just massively trolled.

Name: Anonymous 2010-06-10 10:52

>>108
Nicecover-up.

Name: Anonymous 2010-06-10 11:35

>>109
Nonsense.

I'm a /prog/ regular. This was actually one of my first attempts at trolling.

Name: !!d6eR1C8TTMrCUDA 2010-06-10 15:49

Intel Core2 Duo E7500 w/ that one cracker posted with the openssl libs gets:

611738 trips/second (1000000 in 1634687 ms)
621377 trips/second (1000000 in 1609329 ms)
630267 trips/second (1000000 in 1586630 ms)

someone else share results

Name: Anonymous 2010-06-10 16:33

>>111
i get about 300K trips/sec with a 5-year-old pentium m using my own cracker that uses openssl.

Name: Anonymous 2010-06-10 16:43

>>112
Buy a shitload of them at 70 USD each and make a powerful tripcode cracker cluster.

Name: Anonymous 2010-06-10 16:50

What is this obsession with cracking tripcodes?

Name: Anonymous 2010-06-10 17:23

>>114
Lots of computing power and nothing to do with it.

Name: Anonymous 2010-06-10 17:33

>>115
So play some games or do something useful like joining the world community grid

Name: Anonymous 2010-06-10 17:36

>>116
That's not /prog/-related - it is the kind of behaviour the Sussman wouldn't approve of.

Name: Anonymous 2010-06-10 17:58

>>114
It's an entry-level introduction to CPU-bound programming, and an interesting problem in optimization.
Or it can be, at least. A lot of the people in this thread are just morons who want other people to give them a tripcracker so they can pretend finding a novelty tripcode is some sort of achievement on their part.

Name: Anonymous 2010-06-10 19:15

>>118

heeey, words hurt man >:(

Name: Anonymous 2010-06-10 21:12

>>119
Then leave before we make use of doublewords.
Newer Posts
Don't change these.
Name: Email:
Entire Thread Thread List
All trademarks and copyrights on this site are owned by their respective parties. All comments and posts are the responsibility of their own posters.
- Tinychan + 2ch Mode -