Have $100 AGC card laying around I would like it sold for about 65 % off so I want atleast $65 BTC for it.

Hello!  I just checked my bitcoin and I noticed that two transactions were sent towards the community project I started a few months ago.  Though the amounts are small (.0002 & .0009), every little bit helps and I wanted to thank them and make sure they know I recognize their generosity.  I will keep track of this and place it towards equipment for the Community Tool Shed.

Thanks!
D337z

The data's there and it's a fake-RAID from what I can tell.  However, mdadm can't seem to find any metadata on it.  I was wondering if anyone knows of a way to access the RAID 5 data via two RAID disks (I only have the two USB adapters to connect to the laptop) on a non-Intel system that doesn't have RAID.  Any way to read the data via mdadm?  I mean, if it's fake RAID, anyway, it shouldn't be chipset dependent; right?

If anyone's interested, I'll get selling.  The wind generators will probably run about 4-5 BTC, but will supply about 2500 watts of power.  I can compile together a complete system based on what your situation is and ship it all to you in a semi-timely fashion.  I try to find the most efficient setup based on location and what items are available.  Shipping batteries would be difficult, but not impossible.
These alternate power sources can be a game-changer when it comes to mining BTC since it will greatly offset the power consumption of your systems while adding the possibility for some money received from your electric company (unlikely, most likely just a much lower bill).  The return in investment can be seen in about 1.5 - 2 years generally.
Please let me know if anyone is interested.

Thanks!
-D337z

Hi everybody!  It's D337z again!

Anyhow, I'm just going to get right down to it.  I've got a project I want to accomplish for the community and not enough income to fulfill it myself.  So, I'm asking if anyone wants to donate to help me out.  Now, I know what many of you who don't know me will say, "SCAM!  He's totally scamming you!"  Well, I'm going to tell you right here and now that a donation is just that.  You don't get anything out of it but the satisfaction that your money might be going to a good cause.  And yes, I said might.  As with any other donation you've made in your life, unless you're standing right there, you can't be sure where your money went to.
Now to tell you what your donation is supposed to go towards.  I have quite a few neighbors around my neighborhood that can't take care of their lawns due to either financial problems or physical inability.  So, I've acquired a 48 Volt battery-powered lawn mower via FreeCycle that needs 4x 12 Volt 9 Amp batteries to run.  The problem is that I can't afford to get the batteries myself as they surplus to over $120 total.  I can make the repairs myself, so I don't need to ship it to Craftsman to get it fixed.  I was wondering if anyone would like to spare some BTC for the batteries and possibly travel expenses in case I branch out to other people outside of the neighborhood who need free lawn care.
The way I see it, my home town here has a law that says that grass can not exceed 8 inches in height or they will fine the owner of the home.  If someone can't afford to be mowing their lawn, they can't pay the fine.  If they're unable to physically mow their lawn, it's adding insult to injury.  I already know of a few people around the neighborhood who could use my free help, so I'll be making at least a small difference.  The mower will last about 10 years on the 4x batteries.  And any excess donations will go towards other community projects...which I haven't decided on yet but may include household wind turbines.

Well, feel free to forward any questions or accusations to me personally.

Take care!
D337z

Donations to:  16U1teSxRLpP64NeSAJ3CSoEqwZq4fgonT
Every little bit helps!

Edit:  I think I've decided to open a community tool shed where the community can get what tools they need lent to them for free.  I think it's the only way to be truly fair about it.

Hey everyone!  I just thought I would post here about a project I'm working on to get alternative energy sources approved in towns and cities around where I live.  Unfortunately, it's not an easy thing to accomplish.  So, here's a link to my project:
http://www.gofundme.com/18zs84
Please help out if you can!  Thanks everyone!
Let's try to make this world a better place for everyone.  ^_^

Ever get that block solved that you wish you had been able to hold onto yourself?
Well, why not?
Solo mining won't accept the partial results that pools will, but they will accept the solved block.  SO, why not have your miner mining for both your solo miner and your pool miner at the same time?  Only, when you get that block solved, submit it to your solo miner for the full 50 BTC!
Yes, I know that this may cheat some pools out of BTC, but they each still have the data leading up to the block.
However, if done right, this might help to even the playing field for those with slow miners.   

Hey, just wondering if anyone has done any work on mining via a PowerPC that I could expand upon.  I have a small plan that will allow mining via a very simple device, but my scrypt-ing skills are below par.   
I suppose I could take a swing at it, but I'm far less familiar with scrypt than I am with SHA-256.  Are there any papers on it that I might be able to work from?  Thanks!

-Erick

Hey guys, I was just wondering how many of you successful people got your start.  I other words, how could one go from hashing one bitcoin in 3 months at a rate of 28 Mhash/sec to running multiple rigs in the Ghash/sec range using only bitcoin?
As it is, I've found it to be a waste to try hashing bitcoin at that rate since I only get maybe .01 BTC every 3 days or so if I'm lucky, so I've been using my hardware for BOINC to help with scientific and medical research.
I'm open to suggestions if you've got 'em.  I'm on a low budget so I can't really be spending any money on equipment other than what I generate; so I'm looking for ways to make BTC.  I've taken to selling items for BTC, but it's slow going.

Can anyone offer any advice?
And what are the chances of me hitting a block with that small of a rate?

Hey guys, some of you know me, some of you don't.
It's been a while since I've been on, but I'm back and trying to get something going to keep my life in order.  That's right, I'm jobless.  So, I'm going to start offering a few items on here to make ends meet.  

I'm offering an Aruduino Mega2560 Rev3 (Newest model) for 7.5 BTC.  I'm charging 7.5 BTC because of the fluctuations of the market.  And so, I'm taking the margin into account.  This also helps to pay for any taxes between countries I might incur.  If you're interested, let me know!  

I can also get a few other Arduino models if you're interested.  I'll toss you a price based on what you're looking for.

Hey all!  It's your loveable, hugable D337z!
So, I was looking at the possibility of getting an HD5970, but I was wondering how long it would take to see a return on investment.
Now, I'm decent with math, but I have trouble getting numbers flipped around.  Also, real-world beats paper...because it has rocks.
So, what are some of you seeing out of your HD5970 cards in about a week?  Or, better yet, how long until return on investment?

Thanks!

Hey everyone!  I was wondering if anyone wants to tackle the daunting work of tossing together a PS3 based miner that you don't have to have Linux to use?  It'll be based off of the PSL1ght SDK and accessible via CFW without the need to install Linux.  This gives it more resources and makes it a viable screensaver for PS3.  It also opens the bitcoin mining scene to any PS3 users.  Via Linux, the PS3 should mine at about 15 Mhashes/s.  However, with some tweaking, I'm sure we could squeeze something more out of it.
If anyone wants to help tackle it, I'm way over my head with this project so it'll be a learning experience.  Anyone up for the fun?

[12USr17HQQNse3NZM8foyVM5KbLsS3quwA]

Hey everyone.  I don't normally do this sort of thing, but I'm asking if anyone can help out a friend of mine who's apartment burned down yesterday.  She's lost clothes, books, her bed, laptop, etc. so I'm trying to help her rebuild her life.  I would appreciate if you could help me help her too.
I'm accepting donations via bitcoin, paypal, dwolla, etc.
The addresses are:

Bitcoin:  12USr17HQQNse3NZM8foyVM5KbLsS3quwA
Dwolla:  812-518-9397
Paypal:  Cryo_rebirth@yahoo.com

Note that these do not route directly to her, but I don't want to post her Paypal address here as it's personal information.  I'll route everything to her.  Thank you SO much in advance to anyone that helps.  It seems her Valentine's Day wasn't so good, but we can at least show her a bit of love.  ^_^

-D337z

[12HWUSguWXRCQKfkPeJygVR1ex5wbg3hAq]

Hey everyone!  I've decided to add Diapolo's GOFFSET option to Phatk2.  In some cases, it works better, in others, it doesn't.  Enable it to find out via GOFFSET!
This kernel is for Phoenix 2.0.0.

Currently, I test kernels on an ATI HD5450 graphics card.  If anyone wants to help further my OpenCL expertise, I happily welcome donations to 12HWUSguWXRCQKfkPeJygVR1ex5wbg3hAq.  They'll be put towards a new GPU or two (VLIW and GCN) and programming guides so I can compile optimum code.  I already have the ideas, now I just need to get them out in the open.  I'll also be helping Diapolo test his kernel and donate to help him out.  (A day's worth of hashing each week should be enough)

Code:

// This file is in the public domain

#ifdef VECTORS8
typedef uint8 u;
#elif defined VECTORS4
typedef uint4 u;
#elif defined VECTORS
typedef uint2 u;
#else
typedef uint u;
#endif

__constant uint K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};

__constant uint ConstW[128] = {
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000000U, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000280U,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000U, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000100U,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
};

__constant uint H[8] = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
};

#ifdef BITALIGN
#pragma OPENCL EXTENSION cl_amd_media_ops : enable
#define rot(x, y) amd_bitalign(x, x, (uint)(32 - y))
#else
#define rot(x, y) rotate(x, (uint)y)
#endif

// Some AMD devices have the BFI_INT opcode, which behaves exactly like the
// SHA-256 Ch function, but provides it in exactly one instruction. If
// detected, use it for Ch. Otherwise, use bitselect() for Ch.

#ifdef BFI_INT
// Well, slight problem... It turns out BFI_INT isn't actually exposed to
// OpenCL (or CAL IL for that matter) in any way. However, there is
// a similar instruction, BYTE_ALIGN_INT, which is exposed to OpenCL via
// amd_bytealign, takes the same inputs, and provides the same output.
// We can use that as a placeholder for BFI_INT and have the application
// patch it after compilation.

// This is the BFI_INT function
#define Ch(x, y, z) amd_bytealign(x,y,z)
// Ma can also be implemented in terms of BFI_INT...
#define Ma(z, x, y) amd_bytealign(z^x,y,x)
#else
#define Ch(x, y, z) bitselect(z,y,x)
#define Ma(x, y, z) bitselect(x,y,(z^x))
#endif

//Various intermediate calculations for each SHA round
#define s0(n) (S0(Vals[(0 + 128 - (n)) % 8]))
#define S0(n) (rot(n, 30u)^rot(n, 19u)^rot(n,10u))

#define s1(n) (S1(Vals[(4 + 128 - (n)) % 8]))
#define S1(n) (rot(n, 26u)^rot(n, 21u)^rot(n, 7u))

#define ch(n) Ch(Vals[(4 + 128 - (n)) % 8],Vals[(5 + 128 - (n)) % 8],Vals[(6 + 128 - (n)) % 8])
#define maj(n) Ma(Vals[(1 + 128 - (n)) % 8],Vals[(2 + 128 - (n)) % 8],Vals[(0 + 128 - (n)) % 8])

//t1 calc when W is already calculated
#define t1(n) K[(n) % 64] + Vals[(7 + 128 - (n)) % 8] +  W[(n)] + s1(n) + ch(n)

//t1 calc which calculates W
#define t1W(n) K[(n) % 64] + Vals[(7 + 128 - (n)) % 8] +  W(n) + s1(n) + ch(n)

//Used for constant W Values (the compiler optimizes out zeros)
#define t1C(n) (K[(n) % 64]+ ConstW[(n)]) + Vals[(7 + 128 - (n)) % 8] + s1(n) + ch(n)

//t2 Calc
#define t2(n)  maj(n) + s0(n)

#define rotC(x,n) (x<<n | x >> (32-n))

//W calculation used for SHA round
#define W(n) (W[n] = P4(n) + P3(n) + P2(n) + P1(n))


//Partial W calculations (used for the begining where only some values are nonzero)
#define P1(n) ((rot(W[(n)-2],15u)^rot(W[(n)-2],13u)^((W[(n)-2])>>10U)))
#define P2(n) ((rot(W[(n)-15],25u)^rot(W[(n)-15],14u)^((W[(n)-15])>>3U)))
#define p1(x) ((rot(x,15u)^rot(x,13u)^((x)>>10U)))
#define p2(x) ((rot(x,25u)^rot(x,14u)^((x)>>3U)))
#define P3(n)  W[n-7]
#define P4(n)  W[n-16]

//Partial Calcs for constant W values
#define P1C(n) ((rotC(ConstW[(n)-2],15)^rotC(ConstW[(n)-2],13)^((ConstW[(n)-2])>>10U)))
#define P2C(n) ((rotC(ConstW[(n)-15],25)^rotC(ConstW[(n)-15],14)^((ConstW[(n)-15])>>3U)))
#define P3C(x)  ConstW[x-7]
#define P4C(x)  ConstW[x-16]

//SHA round with built in W calc
#define sharoundW(n) Barrier1(n);  Vals[(3 + 128 - (n)) % 8] += t1W(n); Vals[(7 + 128 - (n)) % 8] = t1W(n) + t2(n);  

//SHA round without W calc
#define sharound(n)  Barrier2(n); Vals[(3 + 128 - (n)) % 8] += t1(n); Vals[(7 + 128 - (n)) % 8] = t1(n) + t2(n);

//SHA round for constant W values
#define sharoundC(n)  Barrier2(n); Vals[(3 + 128 - (n)) % 8] += t1C(n); Vals[(7 + 128 - (n)) % 8] = t1C(n) + t2(n);

//The compiler is stupid... I put this in there only to stop the compiler from (de)optimizing the order
#define Barrier1(n) t1 = t1C((n+1))
#define Barrier2(n) t1 = t1C((n))

__kernel
//removed this to allow detection of invalid work size
//__attribute__((reqd_work_group_size(WORKSIZE, 1, 1)))
void search( const uint state0, const uint state1, const uint state2, const uint state3,
const uint state4, const uint state5, const uint state6, const uint state7,
const uint B1, const uint C1, const uint D1,
const uint F1, const uint G1, const uint H1,
#ifndef GOFFSET
const u base,
#endif
const uint W16, const uint W17,
const uint PreVal4, const uint PreVal0,
const uint PreW31, const uint PreW32,
const uint PreW19, const uint PreW20,
__global uint * output)
{

u W[124];
u Vals[8];

//Dummy Variable to prevent compiler from reordering between rounds
u t1;

//Vals[0]=state0;
Vals[1]=B1;
Vals[2]=C1;
Vals[3]=D1;
//Vals[4]=PreVal4;
Vals[5]=F1;
Vals[6]=G1;
Vals[7]=H1;

W[16] = W16;
W[17] = W17;

#ifdef VECTORS8
#ifdef GOFFSET
W[3] = ((uint)get_global_id(0) << 3) + (u)(0, 1, 2, 3, 4, 5, 6, 7);
uint r = rot(W[3].s0,25u)^rot(W[3].s0,14u)^((W[3].s0)>>3U);
#else
W[3] = base + (uint)(get_local_id(0)) * 8u + (uint)(get_group_id(0)) * (WORKSIZE * 8u);
uint r = rot(W[3].s0,25u)^rot(W[3].s0,14u)^((W[3].s0)>>3U);
//Since only the 2 LSB is opposite between the nonces, we can save an instruction by flipping the 4 bits in W18 rather than the 1 bit in W3
W[18] = PreW20 + (u){r, r ^ 0x2004000U, r ^ 0x4008000U, r ^ 0x600C000U, r ^ 0x8010000U, r ^ 0xA050000U, r ^ 0xC090000U, r ^ 0xE0D0000U};
#endif

#elif defined VECTORS4
#ifdef GOFFSET
W[3] = ((uint)get_global_id(0) << 2) + (u)(0, 1, 2, 3);
uint r = rot(W[3].s0,25u)^rot(W[3].s0,14u)^((W[3].s0)>>3U);
#else

//Less dependencies to get both the local id and group id and then add them
W[3] = base + (uint)(get_local_id(0)) * 4u + (uint)(get_group_id(0)) * (WORKSIZE * 4u);
uint r = rot(W[3].s0,25u)^rot(W[3].s0,14u)^((W[3].s0)>>3U);
//Since only the 2 LSB is opposite between the nonces, we can save an instruction by flipping the 4 bits in W18 rather than the 1 bit in W3
W[18] = PreW20 + (u){r, r ^ 0x2004000U, r ^ 0x4008000U, r ^ 0x600C000U};
#endif
#elif defined VECTORS
#ifdef GOFFSET
W[3] = ((uint)get_global_id(0) << 1) + (u)(0, 1,);
uint r = rot(W[3].s0,25u)^rot(W[3].s0,14u)^((W[3].s0)>>3U);
#else
W[3] = base + (uint)(get_local_id(0)) * 2u + (uint)(get_group_id(0)) * (WORKSIZE * 2u);
uint r = rot(W[3].s0,25u)^rot(W[3].s0,14u)^((W[3].s0)>>3U);
W[18] = PreW20 + (u){r, r ^ 0x2004000U};
#endif
#else
#ifdef GOFFSET
W[3] = ((uint)get_global_id(0));
uint r = rot(W[3].s0,25u)^rot(W[3].s0,14u)^((W[3].s0)>>3U);
#else
W[3] = base + get_local_id(0) + get_group_id(0) * (WORKSIZE);
u r = rot(W[3],25u)^rot(W[3],14u)^((W[3])>>3U);
W[18] = PreW20 + r;
#endif
#endif
//the order of the W calcs and Rounds is like this because the compiler needs help finding how to order the instructions

Vals[4] = PreVal4 + W[3];
Vals[0] = PreVal0 + W[3];

sharoundC(4);
W[19] = PreW19 + W[3];
sharoundC(5);
W[20] = P4C(20) + P1(20);
sharoundC(6);
W[21] = P1(21);
sharoundC(7);
W[22] = P3C(22) + P1(22);
sharoundC(8);
W[23] = W[16] + P1(23);
sharoundC(9);
W[24] = W[17] + P1(24);
sharoundC(10);
W[25] = P1(25) + P3(25);
W[26] = P1(26) + P3(26);
sharoundC(11);
W[27] = P1(27) + P3(27);
W[28] = P1(28) + P3(28);
sharoundC(12);
W[29] = P1(29) + P3(29);
sharoundC(13);
W[30] = P1(30) + P2C(30) + P3(30);
W[31] = PreW31 + (P1(31) + P3(31));
sharoundC(14);
W[32] = PreW32 + (P1(32) + P3(32));
sharoundC(15);
sharound(16);
sharound(17);
sharound(18);
sharound(19);
sharound(20);
sharound(21);
sharound(22);
sharound(23);
sharound(24);
sharound(25);
sharound(26);
sharound(27);
sharound(28);
sharound(29);
sharound(30);
sharound(31);
sharound(32);
sharoundW(33);
sharoundW(34);
sharoundW(35);
sharoundW(36);
sharoundW(37);
sharoundW(38);
sharoundW(39);
sharoundW(40);
sharoundW(41);
sharoundW(42);
sharoundW(43);
sharoundW(44);
sharoundW(45);
sharoundW(46);
sharoundW(47);
sharoundW(48);
sharoundW(49);
sharoundW(50);
sharoundW(51);
sharoundW(52);
sharoundW(53);
sharoundW(54);
sharoundW(55);
sharoundW(56);
sharoundW(57);
sharoundW(58);
sharoundW(59);
sharoundW(60);
sharoundW(61);
sharoundW(62);
sharoundW(63);

W[64]=state0+Vals[0];
W[65]=state1+Vals[1];
W[66]=state2+Vals[2];
W[67]=state3+Vals[3];
W[68]=state4+Vals[4];
W[69]=state5+Vals[5];
W[70]=state6+Vals[6];
W[71]=state7+Vals[7];

const u Temp = (0xb0edbdd0U + K[0]) +  W[64];
Vals[0]=H[0];
Vals[1]=H[1];
Vals[2]=H[2];
Vals[3]=0xa54ff53aU + Temp;
Vals[4]=H[4];
Vals[5]=H[5];
Vals[6]=H[6];
Vals[7]=0x08909ae5U + Temp;

#define P124(n) P2(n) + P1(n) + P4(n)

W[80] = P2(80) + P4(80);
sharound(65);
W[81] = P1C(81) + P2(81) + P4(81);
sharound(66);
W[82] = P124(82);
sharound(67);
W[83] = P124(83);
sharound(68);
W[84] = P124(84);
sharound(69);
W[85] = P124(85);
sharound(70);
W[86] = P4(86) + P3C(86) + P2(86) + P1(86);
sharound(71);
W[87] = P4(87) + P3(87) + P2C(87) + P1(87);
sharoundC(72);
W[88] = P1(88) + P4C(88) + P3(88);
sharoundC(73);
W[89] = P3(89) + P1(89);
sharoundC(74);
W[90] = P3(90) + P1(90);
sharoundC(75);
W[91] = P3(91) + P1(91);
sharoundC(76);
W[92] = P3(92) + P1(92);
sharoundC(77);
W[93] = P1(93) + P3(93);
W[94] = P3(94) + P2C(94) + P1(94);
sharoundC(78);
W[95] = P4C(95) + P3(95) + P2(95) + P1(95);
sharoundC(79);
sharound(80);
sharound(81);
sharound(82);
sharound(83);
sharound(84);
sharound(85);
sharound(86);
sharound(87);
sharound(88);
sharound(89);
sharound(90);
sharound(91);
sharound(92);
sharound(93);
sharound(94);
sharound(95);
sharoundW(96);
sharoundW(97);
sharoundW(98);
sharoundW(99);
sharoundW(100);
sharoundW(101);
sharoundW(102);
sharoundW(103);
sharoundW(104);
sharoundW(105);
sharoundW(106);
sharoundW(107);
sharoundW(108);
sharoundW(109);
sharoundW(110);
sharoundW(111);
sharoundW(112);
sharoundW(113);
sharoundW(114);
sharoundW(115);
sharoundW(116);
sharoundW(117);
sharoundW(118);
sharoundW(119);
sharoundW(120);
sharoundW(121);
sharoundW(122);

u v = W[117] + W[108] + Vals[3] + Vals[7] + P2(124) + P1(124) + Ch((Vals[0] + Vals[4]) + (K[59] + W(123)) + s1(123)+ ch(123),Vals[1],Vals[2]);
u g = -(K[60] + H[7]) - S1((Vals[0] + Vals[4]) + (K[59] + W(123)) + s1(123)+ ch(123));

uint nonce = 0;
#ifdef VECTORS8
if (v.s0 == g.s0)
{
nonce = W[3].s0;
}
if (v.s1 == g.s1)
{
nonce = W[3].s1;
}
if (v.s2 == g.s2)
{
nonce = W[3].s2;
}
if (v.s3 == g.s3)
{
nonce = W[3].s3;
}
if (v.s4 == g.s4)
{
nonce = W[3].s4;
}
if (v.s5 == g.s5)
{
nonce = W[3].s5;
}
if (v.s6 == g.s6)
{
nonce = W[3].s6;
}
if (v.s7 == g.s7)
{
nonce = W[3].s7;
}
#elif defined VECTORS4
if (v.s0 == g.s0)
{
nonce = W[3].s0;
}
if (v.s1 == g.s1)
{
nonce = W[3].s1;
}
if (v.s2 == g.s2)
{
nonce = W[3].s2;
}
if (v.s3 == g.s3)
{
nonce = W[3].s3;
}
#elif defined VECTORS
if (v.s0 == g.s0)
{
nonce = W[3].s0;
}
if (v.s1 == g.s1)
{
nonce = W[3].s1;
}
#else
if (v == g)
{
nonce = W[3];
}
#endif
if(nonce)
{
//Faster to shift the nonce by 2 due to 4-DWORD addressing and does not add more collisions
output[WORKSIZE] = nonce;
output[get_local_id(0)] = nonce;
}
}

As you may be able to tell, I've started adding VECTORS8 to the code as well, but I am having difficulty keeping it from spilling over into memory.  If someone could assist me with this, I would appreciate it.

Hey all!  I'm sort of new to the OpenCL coding scene and I decided I wanted to try my hand at coding a kernel for Phoenix Miner.  So, I'm deciding to attempt to use 128-bit (and possibly 256-bit) vectors to compute SHA-512 hashes and then truncate them to SHA-256 for enhanced speed.  ^_^
If anyone wants to help, let me know!  I could us it.

Hey, I was just wondering about orders.  Are the prices for each coin up to the given amount, or for all the coins total?

Hey, I was wondering if someone could send me an invite to Bitcoin Market?  I don't know anyone else that uses the market let alone bitcoins so I'm sort of on the outside looking in.  I would really appreciate it!  ^___^

Hello, I am looking at building a rig with 4x HD6990 cards in it and I wanted to know if I would be required to connect each card to a display before their GPUs would be activated for mining.  I know in past calculation programs, it was required for a display or null to be connected to at least one port of each card before the GPUs would do any work; has this changed with OpenCL or do I need to invest in null devices?

Thanks!