This is a little GPL Python script that I wrote to try and get better at python. It uses PyCryptsy (no point reinventing the wheel), and trades using EMA 10/21. There is nothing particularly special about it, other than the fact it's open-source.

I make no promises about how good or bad it is - if you lose money, it's your fault for running it.
It is also probably pretty buggy.

Download.

Matthew:out

Block rewards halving is a very uneven way of increasing rarity of coins.

What if the block reward went down more smoothly, like using a percentage decrease factor?

Matthew:out

I have a bunch of steam keys left over from some humble bundles that I have zero intention of using.

The games I have are:

Humble Bundle with Android 5
Dynamite Jack
Beat Hazard Ultra
Nightsky
Solar 2
Super Hexagon
Dungeon Defenders (w/ all DLC)
Superbrothers: Sword and Sworcery EP
Splice
Crayon Physics Deluxe

Humble Indie Bundle 8
Dear Esther
Capsized
Thomas was Alone
Little Inferno
Awesomenauts
Awesomenauts Cluck Costume -- Is there a point to selling this if the original game has been bought?
Hotline Miami
Proteus
Tiny and Big in Grandpa's Leftovers
English Country Tune
Intrusion 2
Oil Rush

If you are interested, then send me a PM. First come first serve!

You can pay (almost) anything you want for these, but I'm not accepting dust.

Matthew:out

In a small flash of inspiration, I came up with a new cypher (which I call "Isenberg" after a friend of mine). Important thing is - is it secure? (I doubt it, personally, but it does seem to resist preimage attacks(!)) To test this, I need firepower which I personally don't have.

This is the code I used (the hash function is hashword()) which is really rather simple when you get down to it.

Code:

#include <stdio.h>

#define U64 unsigned long long
#define C64(x) x##ULL

U64 flipDiagA1H8(U64 x) {
   U64 t;
   const U64 k1 = C64(0x5500550055005500);
   const U64 k2 = C64(0x3333000033330000);
   const U64 k4 = C64(0x0f0f0f0f00000000);
   t  = k4 & (x ^ (x << 28));
   x ^=       t ^ (t >> 28) ;
   t  = k2 & (x ^ (x << 14));
   x ^=       t ^ (t >> 14) ;
   t  = k1 & (x ^ (x <<  7));
   x ^=       t ^ (t >>  7) ;
   return x;
}

U64 flipVertical(U64 x) {
    return  ( (x << 56)                           ) |
            ( (x << 40) & C64(0x00ff000000000000) ) |
            ( (x << 24) & C64(0x0000ff0000000000) ) |
            ( (x <<  8) & C64(0x000000ff00000000) ) |
            ( (x >>  8) & C64(0x00000000ff000000) ) |
            ( (x >> 24) & C64(0x0000000000ff0000) ) |
            ( (x >> 40) & C64(0x000000000000ff00) ) |
            ( (x >> 56) );
}

U64 hashword(U64 x)
{
   // Made up of four parts
   // Flip along antidiagonal
   U64 x1 = flipDiagA1H8(x);

   // Flip vertically
   x1 = flipVertical(x1);

   // XOR
   x1 = x ^ x1;

   // Add one

   x1++;

   return x1;
}

int main()
{
   U64 input = 0;
   U64 output = 0;
   int collisions = 0;

   for (; input < 0xFFFFFFF; input++) {
      output = hashword(input);
      if (output == input) {
         printf("%d hashes to itself!\n", input);
      }
   }
   return 0;
}

I have no significant amount of bitcoins to offer as a reward, but it might prove useful as a small challenge.

Matthew:out

...How would you do it?

I, personally, would use something like AES as the base cypher, due to AES-NI. But then, AES is pretty easy to implement on a GPU.

I note Quark uses multiple cyphers, but again, those aren't hard to put on a GPU.

Matthew:out

I'm doing some hacking with the cgminer 2.9.6 source (there are still people who CPU mine for the novelty of it), and I was wondering if it would be more efficient (i.e. shorter time to a share) to use all available resources to focus on one share or give each resource a seperate share.

Matthew:out