Beiträge von Andy

**Andy**

Zitat

Die Anzahl der Arrays kann ja aber variieren da sie ja abhängig sind von der Anzahl der Checkboxen .... Verstanden ???

Nein
Die Anzahl der Arrays ist nur dann relevant, wenn die Checkboxen die maximal mögliche Anzahl überschreiten...
Lege die Anzahl der Checkboxen(Arrays) auf 24345 fest.
Wenn die Anzahl der Checkboxen diese Zahl überschreiten, dann musst du dir etwas einfallen lassen....
Wenn die Anzahl der Checkboxen diese Zahl unterschreiten, dimensionierst du das Array per

[autoit]

REDIM()

[/autoit]

auf den gewünschten Wert.

**Andy**

Hi,

Zitat

Ich versteh nicht warum nicht so wie es eigentlich vohabe
EDIT:
Habe gerade festgestellt das z.b. der Proxy 178.32.223.88:3128 zwar angepingt werden kann aber nicht als Proxy funktioniert.

Das funktioniert deswegen nicht, weil du nicht weisst, wie es funktioniert...
Der Proxy ist ein Rechner, der zwischen den anderen Beiden (Start und Ziel) "vermittelt". WAS der dort macht, darauf hast du keinen Einfluß!!!
Mit PING() stellt du lediglich fest, dass der Rechner auf PING() antwortet (oder auch nicht). Welche Dienste er anbietet, davon weiss PING() nichts!
Die einzige Möglichkeit herauszufinden, welche Dienste der Proxy anbietet, ist einfach, diese Dienste auszuprobieren....wenns funktioniert, dann gut, wenn nicht, dann eben nicht.
Wenn der Proxy heute auf die wieistmeineip-Anfrage antwortet heisst das nicht, dass er das morgen auch macht. Also passe dein Script darauf an und frage die Rückgaben des Proxys ab...

**Andy**

Hi,

Zitat

Also ein Script, womit man hash Codes ausrechnen kann, mithilfe der CPU oder GPU. Ist so etwas überhaupt mit Autoit möglich ?

Ja, das ist mit AutoIt möglich.
Wie schon angesprochen, bietet sich dafür OpenCL an.
Das Grundgerüst für die Berechnung mit OpenCL ist gerade in AutoIt sehr einfach gehalten, alles was du brauchst ist der entsprechende OpenCL-Kernel. Dieser ist in einer C-ähnlichen Sprache erstellt und wird vor der Laufzeit vom Treiber compiliert. z.B. den hier

Spoiler anzeigen

Code

// This file is in the public domain


#ifdef 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
};


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


// Some AMD devices have a 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((u)x, (u)y, (u)z)
	// Ma can also be implemented in terms of BFI_INT...
	#define Ma(x, y, z) amd_bytealign(((u)z^(u)x), (u)y, (u)x)
#else
	#define Ch(x, y, z) ((u)z ^ ((u)x & ((u)y ^ (u)z)))
	#define Ma(x, y, z) (((u)x & (u)z) | ((u)y & ((u)x | (u)z)))
#endif


__kernel 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,
						const uint base,
						const uint fW0, const uint fW1, const uint fW2, const uint fW3, const uint fW15, const uint fW01r, const uint fcty_e, const uint fcty_e2,
						__global uint * output)
{
	u W0, W1, W2, W3, W4, W5, W6, W7, W8, W9, W10, W11, W12, W13, W14, W15;
	u A,B,C,D,E,F,G,H;
	u nonce;
#ifdef VECTORS4
	#ifdef GOFFSET
		nonce = (get_global_id(0)<<2) + (u)(0, 1, 2, 3);
	#else
		nonce = ((base + get_global_id(0))<<2) + (u)(0, 1, 2, 3);
	#endif
#elif defined VECTORS
	#ifdef GOFFSET
		nonce = (get_global_id(0)<<1) + (u)(0, 1);
	#else
		nonce = ((base + get_global_id(0))<<1) + (u)(0, 1);
	#endif
#else
	#ifdef GOFFSET
		nonce = get_global_id(0);
	#else
		nonce = base + get_global_id(0);
	#endif
#endif


	W3 = nonce + fW3;
	E = fcty_e +  nonce; A = state0 + E; E = E + fcty_e2;
	D = D1 + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B1, C1) + K[ 4] +  0x80000000; H = H1 + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G1, E, F1);
	C = C1 + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B1) + K[ 5]; G = G1 + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F1, D, E);
	B = B1 + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[ 6]; F = F1 + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[ 7]; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[ 8]; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[ 9]; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[10]; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[11]; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[12]; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[13]; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[14]; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[15] + 0x00000280U; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[16] + fW0; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[17] + fW1; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W2 = (rotr(nonce, 7) ^ rotr(nonce, 18) ^ (nonce >> 3U)) + fW2;
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[18] +  W2; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[19] +  W3; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W4 = (rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >> 10U)) + 0x80000000; 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[20] +  W4; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W5 = (rotr(W3, 17) ^ rotr(W3, 19) ^ (W3 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[21] +  W5; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W6 = (rotr(W4, 17) ^ rotr(W4, 19) ^ (W4 >> 10U)) + 0x00000280U; 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[22] +  W6; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W7 = (rotr(W5, 17) ^ rotr(W5, 19) ^ (W5 >> 10U)) + fW0; 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[23] +  W7; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W8 = (rotr(W6, 17) ^ rotr(W6, 19) ^ (W6 >> 10U)) + fW1; 
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[24] +  W8; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W9 = W2 + (rotr(W7, 17) ^ rotr(W7, 19) ^ (W7 >> 10U));
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[25] +  W9; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W10 = W3 + (rotr(W8, 17) ^ rotr(W8, 19) ^ (W8 >> 10U)); 
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[26] + W10; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W11 = W4 + (rotr(W9, 17) ^ rotr(W9, 19) ^ (W9 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[27] + W11; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W12 = W5 + (rotr(W10, 17) ^ rotr(W10, 19) ^ (W10 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[28] + W12; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W13 = W6 + (rotr(W11, 17) ^ rotr(W11, 19) ^ (W11 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[29] + W13; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W14 = 0x00a00055U + W7 + (rotr(W12, 17) ^ rotr(W12, 19) ^ (W12 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[30] + W14; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W15 = fW15 + W8 + (rotr(W13, 17) ^ rotr(W13, 19) ^ (W13 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[31] + W15; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W0 = fW01r + W9 + (rotr(W14, 17) ^ rotr(W14, 19) ^ (W14 >> 10U));
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[32] +  W0; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W1 = fW1 + (rotr(W2, 7) ^ rotr(W2, 18) ^ (W2 >> 3U)) + W10 + (rotr(W15, 17) ^ rotr(W15, 19) ^ (W15 >> 10U));
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[33] +  W1; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W2 = W2 + (rotr(W3, 7) ^ rotr(W3, 18) ^ (W3 >> 3U)) + W11 + (rotr(W0, 17) ^ rotr(W0, 19) ^ (W0 >> 10U));
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[34] +  W2; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W3 = W3 + (rotr(W4, 7) ^ rotr(W4, 18) ^ (W4 >> 3U)) + W12 + (rotr(W1, 17) ^ rotr(W1, 19) ^ (W1 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[35] +  W3; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W4 = W4 + (rotr(W5, 7) ^ rotr(W5, 18) ^ (W5 >> 3U)) + W13 + (rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[36] +  W4; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W5 = W5 + (rotr(W6, 7) ^ rotr(W6, 18) ^ (W6 >> 3U)) + W14 + (rotr(W3, 17) ^ rotr(W3, 19) ^ (W3 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[37] +  W5; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W6 = W6 + (rotr(W7, 7) ^ rotr(W7, 18) ^ (W7 >> 3U)) + W15 + (rotr(W4, 17) ^ rotr(W4, 19) ^ (W4 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[38] +  W6; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W7 = W7 + (rotr(W8, 7) ^ rotr(W8, 18) ^ (W8 >> 3U)) + W0 + (rotr(W5, 17) ^ rotr(W5, 19) ^ (W5 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[39] +  W7; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W8 = W8 + (rotr(W9, 7) ^ rotr(W9, 18) ^ (W9 >> 3U)) + W1 + (rotr(W6, 17) ^ rotr(W6, 19) ^ (W6 >> 10U)); 
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[40] +  W8; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W9 = W9 + (rotr(W10, 7) ^ rotr(W10, 18) ^ (W10 >> 3U)) + W2 + (rotr(W7, 17) ^ rotr(W7, 19) ^ (W7 >> 10U)); 
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[41] +  W9; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W10 = W10 + (rotr(W11, 7) ^ rotr(W11, 18) ^ (W11 >> 3U)) + W3 + (rotr(W8, 17) ^ rotr(W8, 19) ^ (W8 >> 10U)); 
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[42] + W10; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W11 = W11 + (rotr(W12, 7) ^ rotr(W12, 18) ^ (W12 >> 3U)) + W4 + (rotr(W9, 17) ^ rotr(W9, 19) ^ (W9 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[43] + W11; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W12 = W12 + (rotr(W13, 7) ^ rotr(W13, 18) ^ (W13 >> 3U)) + W5 + (rotr(W10, 17) ^ rotr(W10, 19) ^ (W10 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[44] + W12; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W13 = W13 + (rotr(W14, 7) ^ rotr(W14, 18) ^ (W14 >> 3U)) + W6 + (rotr(W11, 17) ^ rotr(W11, 19) ^ (W11 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[45] + W13; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W14 = W14 + (rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >> 3U)) + W7 + (rotr(W12, 17) ^ rotr(W12, 19) ^ (W12 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[46] + W14; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W15 = W15 + (rotr(W0, 7) ^ rotr(W0, 18) ^ (W0 >> 3U)) + W8 + (rotr(W13, 17) ^ rotr(W13, 19) ^ (W13 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[47] + W15; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W0 = W0 + (rotr(W1, 7) ^ rotr(W1, 18) ^ (W1 >> 3U)) + W9 + (rotr(W14, 17) ^ rotr(W14, 19) ^ (W14 >> 10U));
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[48] +  W0; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W1 = W1 + (rotr(W2, 7) ^ rotr(W2, 18) ^ (W2 >> 3U)) + W10 + (rotr(W15, 17) ^ rotr(W15, 19) ^ (W15 >> 10U));
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[49] +  W1; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W2 = W2 + (rotr(W3, 7) ^ rotr(W3, 18) ^ (W3 >> 3U)) + W11 + (rotr(W0, 17) ^ rotr(W0, 19) ^ (W0 >> 10U));
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[50] +  W2; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W3 = W3 + (rotr(W4, 7) ^ rotr(W4, 18) ^ (W4 >> 3U)) + W12 + (rotr(W1, 17) ^ rotr(W1, 19) ^ (W1 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[51] +  W3; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W4 = W4 + (rotr(W5, 7) ^ rotr(W5, 18) ^ (W5 >> 3U)) + W13 + (rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[52] +  W4; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W5 = W5 + (rotr(W6, 7) ^ rotr(W6, 18) ^ (W6 >> 3U)) + W14 + (rotr(W3, 17) ^ rotr(W3, 19) ^ (W3 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[53] +  W5; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W6 = W6 + (rotr(W7, 7) ^ rotr(W7, 18) ^ (W7 >> 3U)) + W15 + (rotr(W4, 17) ^ rotr(W4, 19) ^ (W4 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[54] +  W6; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W7 = W7 + (rotr(W8, 7) ^ rotr(W8, 18) ^ (W8 >> 3U)) + W0 + (rotr(W5, 17) ^ rotr(W5, 19) ^ (W5 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[55] +  W7; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W8 = W8 + (rotr(W9, 7) ^ rotr(W9, 18) ^ (W9 >> 3U)) + W1 + (rotr(W6, 17) ^ rotr(W6, 19) ^ (W6 >> 10U)); 
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[56] +  W8; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W9 = W9 + (rotr(W10, 7) ^ rotr(W10, 18) ^ (W10 >> 3U)) + W2 + (rotr(W7, 17) ^ rotr(W7, 19) ^ (W7 >> 10U)); 
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[57] +  W9; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W10 = W10 + (rotr(W11, 7) ^ rotr(W11, 18) ^ (W11 >> 3U)) + W3 + (rotr(W8, 17) ^ rotr(W8, 19) ^ (W8 >> 10U)); 
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[58] + W10; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W11 = W11 + (rotr(W12, 7) ^ rotr(W12, 18) ^ (W12 >> 3U)) + W4 + (rotr(W9, 17) ^ rotr(W9, 19) ^ (W9 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[59] + W11; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W12 = W12 + (rotr(W13, 7) ^ rotr(W13, 18) ^ (W13 >> 3U)) + W5 + (rotr(W10, 17) ^ rotr(W10, 19) ^ (W10 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[60] + W12; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W13 = W13 + (rotr(W14, 7) ^ rotr(W14, 18) ^ (W14 >> 3U)) + W6 + (rotr(W11, 17) ^ rotr(W11, 19) ^ (W11 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[61] + W13; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W14 = W14 + (rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >> 3U)) + W7 + (rotr(W12, 17) ^ rotr(W12, 19) ^ (W12 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[62] + W14; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W15 = W15 + (rotr(W0, 7) ^ rotr(W0, 18) ^ (W0 >> 3U)) + W8 + (rotr(W13, 17) ^ rotr(W13, 19) ^ (W13 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[63] + W15; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);


	W0 = A + state0; W1 = B + state1;
	W2 = C + state2; W3 = D + state3;
	W4 = E + state4; W5 = F + state5;
	W6 = G + state6; W7 = H + state7;


	H = 0xb0edbdd0 + K[ 0] +  W0; D = 0xa54ff53a + H; H = H + 0x08909ae5U;
	G = 0x1f83d9abU + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + (0x9b05688cU ^ (D & 0xca0b3af3U)) + K[ 1] +  W1; C = 0x3c6ef372U + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) +  Ma(0xbb67ae85U, H, 0x6a09e667U);
	F = 0x9b05688cU + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, 0x510e527fU) + K[ 2] +  W2; B = 0xbb67ae85U + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(0x6a09e667U, G, H);
	E = 0x510e527fU + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[ 3] +  W3; A = 0x6a09e667U + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[ 4] +  W4; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[ 5] +  W5; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[ 6] +  W6; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[ 7] +  W7; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[ 8] +  0x80000000; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[ 9]; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[10]; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[11]; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[12]; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[13]; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[14]; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[15] + 0x00000100U; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W0 = W0 + (rotr(W1, 7) ^ rotr(W1, 18) ^ (W1 >> 3U));
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[16] +  W0; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W1 = W1 + (rotr(W2, 7) ^ rotr(W2, 18) ^ (W2 >> 3U)) + 0x00a00000U;
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[17] +  W1; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W2 = W2 + (rotr(W3, 7) ^ rotr(W3, 18) ^ (W3 >> 3U)) + (rotr(W0, 17) ^ rotr(W0, 19) ^ (W0 >> 10U));
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[18] +  W2; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W3 = W3 + (rotr(W4, 7) ^ rotr(W4, 18) ^ (W4 >> 3U)) + (rotr(W1, 17) ^ rotr(W1, 19) ^ (W1 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[19] +  W3; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W4 = W4 + (rotr(W5, 7) ^ rotr(W5, 18) ^ (W5 >> 3U)) + (rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[20] +  W4; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W5 = W5 + (rotr(W6, 7) ^ rotr(W6, 18) ^ (W6 >> 3U)) + (rotr(W3, 17) ^ rotr(W3, 19) ^ (W3 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[21] +  W5; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W6 = W6 + (rotr(W7, 7) ^ rotr(W7, 18) ^ (W7 >> 3U)) + 0x00000100U + (rotr(W4, 17) ^ rotr(W4, 19) ^ (W4 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[22] +  W6; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W7 = W7 + 0x11002000U + W0 + (rotr(W5, 17) ^ rotr(W5, 19) ^ (W5 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[23] +  W7; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W8 = 0x80000000 + W1 + (rotr(W6, 17) ^ rotr(W6, 19) ^ (W6 >> 10U)); 
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[24] +  W8; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W9 = W2 + (rotr(W7, 17) ^ rotr(W7, 19) ^ (W7 >> 10U)); 
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[25] +  W9; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W10 = W3 + (rotr(W8, 17) ^ rotr(W8, 19) ^ (W8 >> 10U)); 
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[26] + W10; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W11 = W4 + (rotr(W9, 17) ^ rotr(W9, 19) ^ (W9 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[27] + W11; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W12 = W5 + (rotr(W10, 17) ^ rotr(W10, 19) ^ (W10 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[28] + W12; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W13 = W6 + (rotr(W11, 17) ^ rotr(W11, 19) ^ (W11 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[29] + W13; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W14 = 0x00400022U + W7 + (rotr(W12, 17) ^ rotr(W12, 19) ^ (W12 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[30] + W14; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W15 = 0x00000100U + (rotr(W0, 7) ^ rotr(W0, 18) ^ (W0 >> 3U)) + W8 + (rotr(W13, 17) ^ rotr(W13, 19) ^ (W13 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[31] + W15; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W0 = W0 + (rotr(W1, 7) ^ rotr(W1, 18) ^ (W1 >> 3U)) + W9 + (rotr(W14, 17) ^ rotr(W14, 19) ^ (W14 >> 10U));
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[32] +  W0; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W1 = W1 + (rotr(W2, 7) ^ rotr(W2, 18) ^ (W2 >> 3U)) + W10 + (rotr(W15, 17) ^ rotr(W15, 19) ^ (W15 >> 10U));
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[33] +  W1; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W2 = W2 + (rotr(W3, 7) ^ rotr(W3, 18) ^ (W3 >> 3U)) + W11 + (rotr(W0, 17) ^ rotr(W0, 19) ^ (W0 >> 10U));
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[34] +  W2; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W3 = W3 + (rotr(W4, 7) ^ rotr(W4, 18) ^ (W4 >> 3U)) + W12 + (rotr(W1, 17) ^ rotr(W1, 19) ^ (W1 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[35] +  W3; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W4 = W4 + (rotr(W5, 7) ^ rotr(W5, 18) ^ (W5 >> 3U)) + W13 + (rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[36] +  W4; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W5 = W5 + (rotr(W6, 7) ^ rotr(W6, 18) ^ (W6 >> 3U)) + W14 + (rotr(W3, 17) ^ rotr(W3, 19) ^ (W3 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[37] +  W5; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W6 = W6 + (rotr(W7, 7) ^ rotr(W7, 18) ^ (W7 >> 3U)) + W15 + (rotr(W4, 17) ^ rotr(W4, 19) ^ (W4 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[38] +  W6; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W7 = W7 + (rotr(W8, 7) ^ rotr(W8, 18) ^ (W8 >> 3U)) + W0 + (rotr(W5, 17) ^ rotr(W5, 19) ^ (W5 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[39] +  W7; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W8 = W8 + (rotr(W9, 7) ^ rotr(W9, 18) ^ (W9 >> 3U)) + W1 + (rotr(W6, 17) ^ rotr(W6, 19) ^ (W6 >> 10U)); 
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[40] +  W8; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W9 = W9 + (rotr(W10, 7) ^ rotr(W10, 18) ^ (W10 >> 3U)) + W2 + (rotr(W7, 17) ^ rotr(W7, 19) ^ (W7 >> 10U)); 
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[41] +  W9; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W10 = W10 + (rotr(W11, 7) ^ rotr(W11, 18) ^ (W11 >> 3U)) + W3 + (rotr(W8, 17) ^ rotr(W8, 19) ^ (W8 >> 10U)); 
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[42] + W10; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W11 = W11 + (rotr(W12, 7) ^ rotr(W12, 18) ^ (W12 >> 3U)) + W4 + (rotr(W9, 17) ^ rotr(W9, 19) ^ (W9 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[43] + W11; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W12 = W12 + (rotr(W13, 7) ^ rotr(W13, 18) ^ (W13 >> 3U)) + W5 + (rotr(W10, 17) ^ rotr(W10, 19) ^ (W10 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[44] + W12; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W13 = W13 + (rotr(W14, 7) ^ rotr(W14, 18) ^ (W14 >> 3U)) + W6 + (rotr(W11, 17) ^ rotr(W11, 19) ^ (W11 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[45] + W13; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W14 = W14 + (rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >> 3U)) + W7 + (rotr(W12, 17) ^ rotr(W12, 19) ^ (W12 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[46] + W14; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W15 = W15 + (rotr(W0, 7) ^ rotr(W0, 18) ^ (W0 >> 3U)) + W8 + (rotr(W13, 17) ^ rotr(W13, 19) ^ (W13 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[47] + W15; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W0 = W0 + (rotr(W1, 7) ^ rotr(W1, 18) ^ (W1 >> 3U)) + W9 + (rotr(W14, 17) ^ rotr(W14, 19) ^ (W14 >> 10U));
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[48] +  W0; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W1 = W1 + (rotr(W2, 7) ^ rotr(W2, 18) ^ (W2 >> 3U)) + W10 + (rotr(W15, 17) ^ rotr(W15, 19) ^ (W15 >> 10U));
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[49] +  W1; C = C + G; G = G + (rotr(H, 2) ^ rotr(H, 13) ^ rotr(H, 22)) + Ma(B, H, A);
	W2 = W2 + (rotr(W3, 7) ^ rotr(W3, 18) ^ (W3 >> 3U)) + W11 + (rotr(W0, 17) ^ rotr(W0, 19) ^ (W0 >> 10U));
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[50] +  W2; B = B + F; F = F + (rotr(G, 2) ^ rotr(G, 13) ^ rotr(G, 22)) + Ma(A, G, H);
	W3 = W3 + (rotr(W4, 7) ^ rotr(W4, 18) ^ (W4 >> 3U)) + W12 + (rotr(W1, 17) ^ rotr(W1, 19) ^ (W1 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[51] +  W3; A = A + E; E = E + (rotr(F, 2) ^ rotr(F, 13) ^ rotr(F, 22)) + Ma(H, F, G);
	W4 = W4 + (rotr(W5, 7) ^ rotr(W5, 18) ^ (W5 >> 3U)) + W13 + (rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >> 10U)); 
	D = D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[52] +  W4; H = H + D; D = D + (rotr(E, 2) ^ rotr(E, 13) ^ rotr(E, 22)) + Ma(G, E, F);
	W5 = W5 + (rotr(W6, 7) ^ rotr(W6, 18) ^ (W6 >> 3U)) + W14 + (rotr(W3, 17) ^ rotr(W3, 19) ^ (W3 >> 10U)); 
	C = C + (rotr(H, 6) ^ rotr(H, 11) ^ rotr(H, 25)) + Ch(H, A, B) + K[53] +  W5; G = G + C; C = C + (rotr(D, 2) ^ rotr(D, 13) ^ rotr(D, 22)) + Ma(F, D, E);
	W6 = W6 + (rotr(W7, 7) ^ rotr(W7, 18) ^ (W7 >> 3U)) + W15 + (rotr(W4, 17) ^ rotr(W4, 19) ^ (W4 >> 10U)); 
	B = B + (rotr(G, 6) ^ rotr(G, 11) ^ rotr(G, 25)) + Ch(G, H, A) + K[54] +  W6; F = F + B; B = B + (rotr(C, 2) ^ rotr(C, 13) ^ rotr(C, 22)) + Ma(E, C, D);
	W7 = W7 + (rotr(W8, 7) ^ rotr(W8, 18) ^ (W8 >> 3U)) + W0 + (rotr(W5, 17) ^ rotr(W5, 19) ^ (W5 >> 10U)); 
	A = A + (rotr(F, 6) ^ rotr(F, 11) ^ rotr(F, 25)) + Ch(F, G, H) + K[55] +  W7; E = E + A; A = A + (rotr(B, 2) ^ rotr(B, 13) ^ rotr(B, 22)) + Ma(D, B, C);
	W8 = W8 + (rotr(W9, 7) ^ rotr(W9, 18) ^ (W9 >> 3U)) + W1 + (rotr(W6, 17) ^ rotr(W6, 19) ^ (W6 >> 10U)); 
	H = H + (rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25)) + Ch(E, F, G) + K[56] +  W8; D = D + H; H = H + (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Ma(C, A, B);
	W9 = W9 + (rotr(W10, 7) ^ rotr(W10, 18) ^ (W10 >> 3U)) + W2 + (rotr(W7, 17) ^ rotr(W7, 19) ^ (W7 >> 10U)); 
	G = G + (rotr(D, 6) ^ rotr(D, 11) ^ rotr(D, 25)) + Ch(D, E, F) + K[57] +  W9; C = C + G;
	W10 = W10 + (rotr(W11, 7) ^ rotr(W11, 18) ^ (W11 >> 3U)) + W3 + (rotr(W8, 17) ^ rotr(W8, 19) ^ (W8 >> 10U)); 
	F = F + (rotr(C, 6) ^ rotr(C, 11) ^ rotr(C, 25)) + Ch(C, D, E) + K[58] + W10; B = B + F;
	W11 = W11 + (rotr(W12, 7) ^ rotr(W12, 18) ^ (W12 >> 3U)) + W4 + (rotr(W9, 17) ^ rotr(W9, 19) ^ (W9 >> 10U)); 
	E = E + (rotr(B, 6) ^ rotr(B, 11) ^ rotr(B, 25)) + Ch(B, C, D) + K[59] + W11; A = A + E;
	W12 = W12 + (rotr(W13, 7) ^ rotr(W13, 18) ^ (W13 >> 3U)) + W5 + (rotr(W10, 17) ^ rotr(W10, 19) ^ (W10 >> 10U)); 
	H = H + D + (rotr(A, 6) ^ rotr(A, 11) ^ rotr(A, 25)) + Ch(A, B, C) + K[60] + W12;


	H+=0x5be0cd19U;


#ifdef VECTORS4
	if (H.x == 0)
	{
		output[WORKSIZE] = output[get_local_id(0)] = nonce.x;
	}
	else if (H.y == 0)
	{
		output[WORKSIZE] = output[get_local_id(0)] = nonce.y;
	}
	else if (H.z == 0)
	{
		output[WORKSIZE] = output[get_local_id(0)] = nonce.z;
	}
	else if (H.w == 0)
	{
		output[WORKSIZE] = output[get_local_id(0)] = nonce.w;
	}
#elif defined VECTORS
	if (H.x == 0)
	{
		output[WORKSIZE] = output[get_local_id(0)] = nonce.x;
	}
	else if (H.y == 0)
	{
		output[WORKSIZE] = output[get_local_id(0)] = nonce.y;
	}
#else
	if (H == 0)
	{
		output[WORKSIZE] = output[get_local_id(0)] = nonce;
	}
#endif
}

Alles anzeigen

oder den

Spoiler anzeigen

Code

// This file is in the public domain


#ifdef 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,
						const u base,
						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[1]=B1;
	Vals[2]=C1;
	Vals[3]=D1;
	Vals[5]=F1;
	Vals[6]=G1;
	Vals[7]=H1;


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


#if defined VECTORS4
	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);
	W[18] = PreW20 + (u){r, r ^ 0x2004000U, r ^ 0x4008000U, r ^ 0x600C000U};
#elif defined VECTORS
	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};
#else
	W[3] = base + get_local_id(0) + get_group_id(0) * (WORKSIZE);
	uint r = rot(W[3],25u)^rot(W[3],14u)^((W[3])>>3U);
	W[18] = PreW20 + r;
#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];


	Vals[0]=H[0];
	Vals[1]=H[1];
	Vals[2]=H[2];
	Vals[3]=H[3];
	Vals[4]=H[4];
	Vals[5]=H[5];
	Vals[6]=H[6];
	Vals[7]=H[7];


	const u Temp = (0xb0edbdd0U + K[0]) +  W[64];
	Vals[7] = Temp + 0x08909ae5U;
	Vals[3] = 0xa54ff53aU + Temp;


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


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


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


	uint nonce = 0;
#ifdef VECTORS4
	if (v.x == g.x)
	{
		nonce = W[3].x;
	}
	if (v.y == g.y)
	{
		nonce = W[3].y;
	}
	if (v.z == g.z)
	{
		nonce = W[3].z;
	}
	if (v.w == g.w)
	{
		nonce = W[3].w;
	}
#elif defined VECTORS
	if (v.x == g.x)
	{
		nonce = W[3].x;
	}
	if (v.y == g.y)
	{
		nonce = W[3].y;
	}
#else
	if (v == g)
	{
		nonce = W[3];
	}
#endif
	if(nonce)
	{
		output[WORKSIZE] = nonce;
		output[get_local_id(0)] = nonce;
	}
}

Alles anzeigen

Die Leistungsfähigkeit beim Bitcoin-Mining ist abhängig von der vorhandenen (Grafik)-Hardware, auf CPU´s gewinnt man keinen Blumenpott...

Den Kernel hast du nun, das ist eigentlich nichts weiter als eine Funktion, die du nur noch mit den entsprechenden Parametern füttern musst...

Zitat

Aber dafür benötigst du dann letztlich ohnehin auch Wissen über andere Sprachen, kannst es also auch gleich in C oder anderen performanteren Hochsprachen programmieren.

genau das ist der Witz, dass man KEINE "performante" Hochsprache programmieren muss!
Da es keine Programmteile gibt, die nur annähernd Performancerelevant sind, ist die Verwendung der "Sprache" ehrlich gesagt völlig egal. Ob man den Kernel in C/C++ einbindet oder in eine beliebige andere Programmiersprache, ändert an der Ausführungsgeschwindigkeit des Kernels auf der entsprechenden Hardware.....NICHTS!

Die Frage lautet eher, ob sich Bitcoin-Mining in Deutschland überhaupt lohnt, da die Berechnung aufgrund der Energiekosten höher ist als das Ergebnis!
Was uns aber nicht abhalten sollte, einen Miner in AutoIt zu schreiben^^

//EDIT mit Phoenix 2.0 und einer ATI Radeon HD6750 schaffe ich 95 MHashes pro Sekunde
mit den 2 Cores des AthlonII X2 250 schaffe ich immerhin 4,5 MHashes/Sekunde !!!

**Andy**

Oscars Glaskugel ist vom Polieren zurück!

**Andy**

Indem du Oscars Postings mehrmals LAUT liest und zu verstehen versuchst, wie er dir helfen kann!
Wer sonst anderes als du kann festlegen, welche ominösen Zahlen in den drei Labels erscheinen sollen?

[so manchmal verstehe ich, wieso sich einige Leute jahrelang nackt auf einen hohen Berg setzen.....die wollen von dem Elend einfach nichts mehr mitbekommen....]

**Andy**

Na klar!

**Andy**

Oscar, stell dich nicht so an, lies mal GENAU was er haben möchte...

Zitat

dass er halt alles ausliest und je nachdem was ausgewählt wurde verschiedene Zahlen auf die 3 Freien Labels setzt

[autoit]

Case $Button1
for $i=1 to 8
$a=eval("combo"&$i)

[/autoit][autoit][/autoit][autoit]

guictrlsetdata($label12,random(1,int(sqrt(int(2^(bitand(random(1,$a,1),0xFFFFFFFF))))),1))
guictrlsetdata($label13,random(1,int(sqrt(int(2^(bitand(random(1,$a,1),0xFFFFFFFF))))),1))
guictrlsetdata($label14,random(1,int(sqrt(int(2^(bitand(random(1,$a,1),0xFFFFFFFF))))),1))
sleep(100)
next

[/autoit]

ERSTER!!!

**Andy**

Hi,

Zitat

Prinzipiell muss ich einfach mal wissen, ob die Anschlussbox der Geräte (wird zwischen Meßgerät und PC geschaltet) überhaupt noch was von sich gibt.

Das Problem bei solchen Konstruktionen ist meist, dass ein unbekanntes Protokoll "erahnt" werden muss.
Ich für meinen Teil habe bei früheren Basteleien immer eine einfache Methode bevorzugt:
Gerät an Port X (meist seriell/parallel) angeschlossen, auf dem Rechner ein Programm gestartet, dass einen (oder mehrere) bestimmte Pins der Schnittstelle abfragt (Hallo, bist du da?), dann vom Rechner aus eine Anfrage geschickt, die dann das Gerät beantwortet hat.
Dieses Procedere kann man bis zum Exzess betreiben, s. sämtliche Protokolle PCI/LAN/WLAN/InstaBus usw.

Du musst "nur" herausfinden, wie sich die beiden Geräte PC und Device unterhalten...Ohne nähere Informationen nahezu unmöglich.
Selbst wenn du eine Sniffersoftware hättest, die dir sämtliche Daten ausgibt, die von dem Gerät kommen, woher willst du wissen, wie du diesem Gerät antworten sollst?
Vielleicht wartet das Gerät bzw. die Anschlussbox auf div. "Nachrichten" bevor sie überhaupt etwas von sich gibt.?

Zitat

....mal den Seitenschneider gezückt haben, weil Zitat: "Ging halt schneller". Ich denke mal mehr muss ich nicht sagen.

Gibts von dem Rechner noch eine Platte oder Software (Backup), die man ggf. in einer VM laufen lassen kann?

Hab mal gegoogelt, für Mitutoyo-Meßzeuge gibts ja unendlich viel Zubehör und Adapterkabel. Leider habe ich nur einige kostenpflichtige Software gefunden, u.a. aber auch ein Programm, dass die Daten des Meßschiebers per Knopfdruck (auf dem Meßschieber) in eine Excel-Tabelle einträgt. Das funktioniert entweder so, dass der Meßschieber eine Tastatur emuliert (merkt man beim Anschluß an den Rechner, Windows installiert Treiber oder erkennt das Gerät), oder per VBA die Schnittstelle angesprochen wird (was, wenn das Protokoll bekannt ist, auch kein Problem sein wird).

Ich würde aber zuerst mal versuchen, das "alte" System zum Laufen zu bekommen. Dann kann man immer noch einen Sniffer dazwischenschalten, um dem Protokoll mal auf den Zahn zu fühlen...

Zitat

Ähm, was für ein Laserscanner gibt den Daten direkt an txt/xls weiter.

Alle, die eine Tastatur emulieren^^, per USB anschliessen, Windows erkennt ein HID, scannen, (Bar)Code wird in Anwendung geschrieben. Wir haben welche von Opticon, kabellos per Bluetooth, klappt einwandfrei!
Man kann das Ganze auch seriell anschliessen, dann braucht man aber das 600-seitige Handbuch...

Zitat

ie Firma von der die verbaute Hardware stammt (Anschlußbox) ist mitlerweile pleite, also ist da wohl eher kein Support mehr zu erwarten

Fragen kostet nix, ggf gibts im Netz ja noch weitere Infos.
Bin gerade über einige Foren von Sammlern von Meßzeugen gestolpert, da würde sich sicher der eine oder andere Thread lohnen!

**Andy**

Hi,
idR. werden die Schnittstellen über Treiber angesprochen, wenn es keine gibt, hilft googeln

Ggf. einfach mal an den PS/2 port anschliessen, eine evtl. vorhandene USB-tastatur abziehen und den Rechner neu booten.
Je nach Einstellung (Handbuch?! ) wird eine Tastatur emuliert (wie bei einem Laser-Scanner) und dann einfach an die Anwendung (Excel/Textverarbeitung) weitergegeben.

Wo hast du denn diese Dinger überhaupt her, ggf. hat derjenige ja noch Software oder Adapterkabel....

**Andy**

Hi,

Zitat

Melden die Antiviren Programme immer bei solchen Code Kompressoren? Wollte es mir runterladen, aber Avast hat mich daran gehindert.

ja, und das ist nicht mal verkehrt!
IdR. packen sich diese Programme selbst, man (selbst und natürlich auch der Virenscanner) hat also keine Chance, herauszufinden, welcher Code sich hinter dem gepackten File verbirgt.
Ob es jetzt wirklich helfen würde, den Packer-Sourcecode zu veröffentlichen, damit den sich jeder selbst compilieren kann, lasse ich mal dahingestellt.
Die Frage stellt sich jetzt natürlich wieso man überhaupt DIESE Packer braucht, Antwort s. minx´ens Startpost!
Wenn du ein sowieso schon eingestampftes File von 1,2KB auf 1024Byte komprimieren musst, dann ist dir auch die Warnung von Avast schnurz....höchstwahrscheinlich hast du auf deiner Maschine dann sowieso kein Avast

**Andy**

Hi,

Zitat

Windows anweisen, eine Funktion in unserem Script aufzurufen,

SO gehört sich das

**Andy**

Hi,

Zitat

Finde in einer Textdatei c:\info.txt "Suchstring1" und speichere alle nachfolgenden Strings bis zum "Suchstring2" in einzelnen Variablen.

[autoit]

stringinstr()

[/autoit]

gibt dir die Position des ersten Suchstrings und des Zweiten.
Mit

[autoit]

stringmid()

[/autoit]

gibts den String dazwischen,

[autoit]

stringsplit()

[/autoit]

trennt den String an bestimmten (in deinem Fall Leer-) Zeichen
Ggf. die Positionen (Ende) per

[autoit]

stringlen()

[/autoit]

ermitteln.

Zitat

Beispieltext: Mein Name ist Max Mustermann und ich wohne in Berlin.
Ergebnis: String1: Vorname= Max,
String2: Nachname= Mustermann

das ist lt deiner Beschreibung unklar!
String1=Mein Name ist
String2=und ich wohne
Ergebnis[1] = Max
Ergebnis[2] =Mustermann

**Andy**

Hi,

Zitat

sorry, habe kurz gesucht, nur nichts gefunden -

Das ist ja wohl die bodenloseste Unverschämtheit und definitiv gelogen!

Deine "Anfrageüberschrift"

Zitat von svart

Anzahl der Vorkommen eines Strings in txt

in google eingegeben, und nur auf AutoIt.de gesucht:
Anzahl der Vorkommen eines Strings in txt site:autoit.de[ so gibt man das bei google ein...]
ergibt in den ersten Threads Lösungstreffer.

Dein 1. Satz

Zitat

ich möchte die Anzahl eines Strings aus einer TXT Datei auslesen,

um die unwichtigen Wörter gekürzt und wiederum bei google eingegeben:
Anzahl String TXT Datei site:AutoIt.de
ergibt als 1. Treffer einen Thread mit Lösung!

Um das mal auf den Punkt zu bringen:
Du bist nicht in der Lage eine Suchanfrage bei Google zu erstellen, stattdessen erstellst Du einen Thread in einem Forum, weil du

Zitat von svart

leider keine Zeit da ich auf der Arbeit bin...

.
Aha, die "anderen" haben sich gefälligst für DEIN Anliegen die Zeit zu nehmen und kostenlos für dich die "Arbeit" zu machen für die DU Geld bekommst?! Wie man so etwas nennt, ist allgemein bekannt In deiner wertvollen Arbeitszeit ist es also in Ordnung, in Foren Threads zu erstellen die in 1/1000 der Zeit von Google gelöst worden wären und dazu noch reihenweise andere Leute von ihrer Arbeit abzuhalten um dir den Arm aus der Sonne zu legen?

Zitat von svart aus anderem Thread

und auf Arbeit habe ich nich soviel Zeit - da ich das nur nebenbei schreiben wollte um mir und meinen Kollegen die Arbeit zu erleichtern, ist nämlich nervig 2-3 Minuten rumzubasteln bis man sich per VNC verbinden kann.

s.o.

Ja, hier ist definitiv ein Forum, bei dem jemandem geholfen wird, und das auch noch sehr schnell!
Da kann sich sicher niemand beschweren. Auch Anfängern wird sehr gerne weitergeholfen.
Aber überflüssige Threads zu erstellen und dann den Helfern auch noch die Hucke vollzulügen, ist eine Frechheit sondersgleichen!

Was mich am meisten Ankotzt ist, dass dein "Bekannter" dir AutoIt und wohl auch dieses Forum empfohlen hat, aber selber nicht bereit oder in der Lage ist, dir deine Arbeit zu machen. Er weiss wohl warum!
Und da du "auf der Arbeit nicht genug Zeit" hast, lese dir daheim mal den Text unter dem Link in meiner Sig zum Thema "Wie man Fragen richtig stellt..." durch.
Vielleicht hilft´s ja, damit dein nächster Thread am Besten gleich entfallen kann!
Ggf. führt es auch dazu, dass du nicht nur Threads erstellst mit dem Ziel, dir und deinen Kollegen die "Arbeit" zu erleichtern, sondern auch mal anderen "Hilfsbedürftigen" mit deinem Wissen unter die Arme zu greifen. Denn genau DAVON lebt ein Forum!
Oder ist deine Zeit dafür zu wertvoll und kostet zu viel?

**Andy**

Hi,
ich habe schon einige Scripte für 1D-Barcodes erstellt, u.a. Barcode39 und 2of5Interleaved.
Das Verfahren ist immer gleich:
Erstelle dir die Abfolge der "Balken" und Leerstellen lt. Barcode-Encoding-Beschreibung.
Schreibe die Abfolge (Barcode) als Bitmap in eine Datei, ggf zusammen mit den restlichen Dokumentdaten.
Drucke das Etikett/Formular auf einen Etikettendrucker.

Alternativ habe ich auch schon für geeignete "einfache" Barcodes Fonts erstellt.
Schon bei 2of5Interleaved ist das eine recht aufwendige Angelegenheit.....

Für 2D-Codes ist das Ganze nochmal aufwendiger.
"Einfach so" erstellt dir definitiv niemand so etwas, eine "saubere" DLL schonmal garnicht, du weißt durch deine Recherchen, was professionelle Programme kosten....

Also setz dich dran und programmiere selbst, schwer ist es nicht, aber wie gesagt aufwendig.
Hilfe bekommst du hier dabei sicher^^

**Andy**

hups, c&p-fehler....

Spoiler anzeigen

[autoit]

filedelete(@ScriptDir & '\Text.txt')
filewrite(@ScriptDir & '\Text.txt',"zeile1"&@crlf&"zeile2"&@crlf&"zeile3"&@crlf) ;text erstellen
msgbox(0,"vorher",fileread(@ScriptDir & '\Text.txt'))

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

$hgui=guicreate("test")
$hinput=guictrlcreateinput("zeile2",1,1)

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

_export($hinput)
msgbox(0,"nachher",fileread(@ScriptDir & '\Text.txt'))

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

Func _export($read1)
Local $sRepl = GUICtrlRead($read1)&@crlf
Local $file = FileOpen("Text.txt", 0)
Local $sText = FileRead($file)
Local $sNewText = StringReplace($sText, $sRepl,"")
FileClose($file)

[/autoit] [autoit][/autoit] [autoit]

filedelete(@ScriptDir & '\Text.txt')
FileWrite(@ScriptDir & '\Text.txt', $sNewText)

[/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit]

Zitat

Damit löscht er mir die gesamte "Text.txt" Datei ohne sie neu zu schreiben.

dann hast du ein Problem, welches nichts mit AutoIt zu tun hat.

[autoit]

filedelete(@ScriptDir & '\Text.txt')
FileWrite(@ScriptDir & '\Text.txt', $sNewText)

[/autoit]

löscht und schreibt eine Datei, wenn das nicht bei dir funktioniert, muss ich passen...

**Andy**

Hi,
so etwa...

Spoiler anzeigen

[autoit]

filedelete(@ScriptDir & '\Text.txt')
filewrite(@ScriptDir & '\Text.txt',"zeile1"&@crlf&"zeile2"&@crlf&"zeile3"&@crlf) ;text erstellen
msgbox(0,"vorher",fileread(@ScriptDir & '\Text.txt'))

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

$hgui=guicreate("test")
$hinput=guictrlcreateinput("zeile2",1,1)

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

_export($hinput)
msgbox(0,"nachher",fileread(@ScriptDir & '\Text.txt'))

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

Func _export($read1)
Local $sRepl = GUICtrlRead($read1)&@crlf
Local $file = FileOpen("Text1.txt", 0)
Local $sText = FileRead($file)
Local $sNewText = StringReplace($sText, $sRepl,"")
FileClose($file)

[/autoit] [autoit][/autoit] [autoit]

filedelete(@ScriptDir & '\Text.txt')
FileWrite(@ScriptDir & '\Text.txt', $sNewText)

[/autoit] [autoit][/autoit] [autoit]

EndFunc

[/autoit]

**Andy**

Hi,

Zitat

Edit: Ups, noch nicht ganz gelöst fürchte ich. Wie kann ich denn nun den String aus der DLL laden (s. oben Bild)?

Wie wärs, wenigstens ausnahmsweise mal, die Suchfunktion zum Thema zu bemühen?
FindResource() hilft dir weiter, woher ich das weiß? Google ist mein Freund! Da habe ich nach nichtmal 10 Sekunden im "blauen" Forum eine (von mehreren) UDF zum Thema Resourcen gefunden....
Wenn du nicht weißt, wie man effizient sucht und findet, wieso fragst du dann nicht?

**Andy**

Na also, geht doch

**Andy**

ok, Aliasing hätte man auch kürzer erklären können, s Script. Habe mal die Rotation weggelassen um DEIN Verständnis von Anti-Aliasing darzustellen.
Dazu einfach nur den Parameter

[autoit]

Local $AntiAliasing = 1

[/autoit]

auf bspw. 2 setzen und tadaaaaa das Bild vorher wird Anti-Aliased...

Spoiler anzeigen

[autoit]

#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

Opt("GUIOnEventMode", 1)

[/autoit] [autoit][/autoit] [autoit]

; Hier rumspielen! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

[/autoit] [autoit][/autoit] [autoit]

Local $ForeRed = 0, $ForeGreen = 0, $ForeBlue = 0 ; Farbe für den Vordergrund (das Äußere)
Local $BackRed = 255, $BackGreen = 0, $BackBlue = 0 ; Hintergrund (das Innere)

[/autoit] [autoit][/autoit] [autoit]

Local $AntiAliasing = 1 ; AA höher als 1x sollte nur bei RotRange > 100 nötig sein!
Local $RotRange = 100 ; Wie stark soll es rotieren

[/autoit] [autoit][/autoit] [autoit]

; Rumspielen beenden! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

$hGUI = GUICreate("PolyPlay | FPS: 0",500,500,-1,-1,Default,34078728)
GUISetBkColor(0)
Global $hGraphics = GUICtrlCreateGraphic(0,0)
GUISetOnEvent(-3, "done")
GUISetState()

[/autoit] [autoit][/autoit] [autoit]

AdlibRegister("FPS", 1000)

[/autoit] [autoit][/autoit] [autoit]

Local $r = -$RotRange, $modificator = 1, $iFPS = 0
While 1
$r += $modificator
If $r > $RotRange Or $r < -$RotRange Then $modificator *= -1
Draw($ForeRed, $ForeGreen, $ForeBlue, $BackRed, $BackGreen, $BackBlue, $r, 100 * $AntiAliasing)
$iFPS += 1
WEnd

[/autoit] [autoit][/autoit] [autoit]

Func Draw($FRed, $FGreen, $FBlue, $BRed, $BGreen, $BBlue, $Rotate, $Step)
$old = $hGraphics
$hGraphics = GUICtrlCreateGraphic(0,0)
Local $ROffSet=($BRed-$FRed)/$Step,$GOffset=($BGreen-$FGreen)/$Step,$BOffset=($BBlue-$FBlue)/$Step,$XOffset=250/$Step,$YOffset=250/$Step
Local $RotateOffset = $Rotate / $Step
Dim $T

[/autoit] [autoit][/autoit] [autoit]

For $T = 0 To $Step
$Color = RGB($FRed+($T*$ROffSet),$FGreen+($T*$GOffset),$FBlue+($T*$BOffset))
GUICtrlSetGraphic($hGraphics,8,$Color,$Color)
;~ GUICtrlSetGraphic($hGraphics,6,250+X(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
;~ GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
; GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T))
GUICtrlSetGraphic($hGraphics,($step>100)*2+10,50, 50,400,400,$RotateOffset*$T)

[/autoit] [autoit][/autoit] [autoit]

Next
GUICtrlSetGraphic($hGraphics, 22)
GUICtrlDelete($old)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func RGB($r, $g, $b)
Return "0x" & Hex(Int($r), 2) & Hex(Int($g), 2) & Hex(Int($b), 2)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func X($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RX * Cos($TZAn) - $RY * Sin($TZAn)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Y($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RY * Cos($TZAn) + $RX * Sin($TZAn)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func FPS()
WinSetTitle("", "", "PolyPlay | FPS: " & $iFPS)
$iFPS = 0
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func done()
Exit
EndFunc

[/autoit]

**Andy**

Du behauptest also, wenn man 2 voneinander unabhängige Bilder zeichnet (Vorher und Nachher) dann dürfte man das Verfahren, in dem man das zweite Bild gezeichnet hat , Anti-Aliasing nennen, nur weil es weniger "Treppenstufen" hat?

Zitat

Man braucht sich doch nur Wu's Linienalgorithmus oder sonstige AA Verfahren auszusehen, die alle Realtime arbeiten.

Naja, ich glaube da wirfst du einiges durcheinander.
Die Algorithmen versuchen den "Treppeneffekt" im Vorfeld zu vermeiden. Wenn ich eine mit welchem Algorithmus auch immer gezeichnete Linie so erstelle, dass sie auf einem Ausgabemedium garnicht ~~Aligned~~ Aliased ist, dann ist das Ziel erreicht.

Zitat

Versuch mal mit Wu's eine ähnlich aliaste Linie wie mit Bresenham zu zeichnen.

Das ist nicht das Thema, das Thema ist, dass du keinerlei veränderten Linienalgorithmus verwendest und somit auch nicht die Linie auf dem Bildschirm an sich! s.Script, da kannst du die Parameter ändern wie du willst, die Linie an sich bleibt IMMER gleich (~~Aligned~~ Aliased^^)!

Spoiler anzeigen

[autoit]

Opt("GUIOnEventMode", 1)

[/autoit] [autoit][/autoit] [autoit]

; Hier rumspielen! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

[/autoit] [autoit][/autoit] [autoit]

Local $ForeRed = 0, $ForeGreen = 0, $ForeBlue = 0 ; Farbe für den Vordergrund (das Äußere)
Local $BackRed = 255, $BackGreen = 0, $BackBlue = 0 ; Hintergrund (das Innere)

[/autoit] [autoit][/autoit] [autoit]

Local $AntiAliasing = 0.4 ; AA höher als 1x sollte nur bei RotRange > 100 nötig sein!
Local $RotRange = 100 ; Wie stark soll es rotieren

[/autoit] [autoit][/autoit] [autoit]

; Rumspielen beenden! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

$hGUI = GUICreate("PolyPlay | FPS: 0",500,500,-1,-1,Default,34078728)
GUISetBkColor(0)
Global $hGraphics = GUICtrlCreateGraphic(0,0)
GUISetOnEvent(-3, "done")
GUISetState()

[/autoit] [autoit][/autoit] [autoit]

AdlibRegister("FPS", 1000)

[/autoit] [autoit][/autoit] [autoit]

Local $r = -$RotRange, $modificator = 1, $iFPS = 0
While 1
$r += $modificator
If $r > $RotRange Or $r < -$RotRange Then $modificator *= -1
Draw($ForeRed, $ForeGreen, $ForeBlue, $BackRed, $BackGreen, $BackBlue, $r, 100 * $AntiAliasing)
$iFPS += 1
WEnd

[/autoit] [autoit][/autoit] [autoit]

Func Draw($FRed, $FGreen, $FBlue, $BRed, $BGreen, $BBlue, $Rotate, $Step)
$old = $hGraphics
$hGraphics = GUICtrlCreateGraphic(0,0)
Local $ROffSet=($BRed-$FRed)/$Step,$GOffset=($BGreen-$FGreen)/$Step,$BOffset=($BBlue-$FBlue)/$Step,$XOffset=250/$Step,$YOffset=250/$Step
Local $RotateOffset = $Rotate / $Step
Dim $T
For $T = 0 To $Step
$Color = RGB($FRed+($T*$ROffSet),$FGreen+($T*$GOffset),$FBlue+($T*$BOffset))
GUICtrlSetGraphic($hGraphics,8,$Color,$Color)
;~ GUICtrlSetGraphic($hGraphics,6,250+X(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
;~ GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
; GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T))
GUICtrlSetGraphic($hGraphics,2,250+X(-(250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T),250+Y(-(250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T))
Next
GUICtrlSetGraphic($hGraphics, 22)
GUICtrlDelete($old)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func RGB($r, $g, $b)
Return "0x" & Hex(Int($r), 2) & Hex(Int($g), 2) & Hex(Int($b), 2)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func X($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RX * Cos($TZAn) - $RY * Sin($TZAn)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func Y($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RY * Cos($TZAn) + $RX * Sin($TZAn)
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func FPS()
WinSetTitle("", "", "PolyPlay | FPS: " & $iFPS)
$iFPS = 0
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func done()
Exit
EndFunc

[/autoit]

Du verwendest jedes Mal den gleichen Linien-Algorithmus, aber zeichnest immer nur ein komplett anderes Bild, in dem sich diese Linien eben so überlagern, dass es einmal "Treppenstufen" anzeigt, und im anderen Bild (aufgrund eines veränderten Parameters) eben nicht...
Das ist so, als ob ich sagen würde, DaVinci´s "Mona Lisa" sei die Anti-Aligned-Version von einem kubistisch gemalten Gesicht....die Beiden haben ~~Aligned~~Aliasing-Technisch genausoviel gemeinsam wie deine "Vorher/Nachher"-Bilder.
Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist. Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.

//EDIT// aliasing <> aligning...Recht hat er^^

Beiträge von Andy

Dynamische Namen für Array Variablen

Proxy Schleife mit HttpSetProxy

Bitcoin Miner mit AutoIt programmieren. Möglich?

(Input)URl mit Standartbrowser auf PC öffnen

Comboboxen mit verschiedenen möglichkeiten auslesen

Comboboxen mit verschiedenen möglichkeiten auslesen

Comboboxen mit verschiedenen möglichkeiten auslesen

PS/2 Anschluß loggen

PS/2 Anschluß loggen

[Demotool] kode kompressor - Extremer EXE Packer

Automatische Laufwerkserkennung

Suchfunktion in Textdateien

Anzahl der Vorkommen eines Strings in txt

PDF147 Barcode

StringReplace

StringReplace

DLL - Frage

PolyPlay - Cooler GDI Effekt

PolyPlay - Cooler GDI Effekt

PolyPlay - Cooler GDI Effekt