Initial data commit

Task/CRC-32/00-META.yaml

@@ -0,0 +1,5 @@
+---
+category:
+- Checksums
+from: http://rosettacode.org/wiki/CRC-32
+note: Checksums

Task/CRC-32/00-TASK.txt

@@ -0,0 +1,13 @@
+;Task:
+Demonstrate a method of deriving the [[wp:Computation of cyclic redundancy checks|Cyclic Redundancy Check]] from within the language. 
+
+
+The result should be in accordance with ISO 3309, [http://www.itu.int/rec/T-REC-V.42-200203-I/en ITU-T V.42], [http://tools.ietf.org/html/rfc1952 Gzip] and [http://www.w3.org/TR/2003/REC-PNG-20031110/ PNG]. 
+
+Algorithms are described on [[wp:Cyclic redundancy check|Computation of CRC]] in Wikipedia. 
+This variant of CRC-32 uses LSB-first order, sets the initial CRC to FFFFFFFF<sub>16</sub>, and complements the final CRC.
+
+For the purpose of this task, generate a CRC-32 checksum for the ASCII encoded string:
+:: <big><big><code>The quick brown fox jumps over the lazy dog</code></big></big>
+<br><br>
+

Task/CRC-32/11l/crc-32.11l

@@ -0,0 +1,18 @@
+V crc_table = [0] * 256
+L(i) 256
+   UInt32 rem = i
+   L 8
+      I rem [&] 1 != 0
+         rem >>= 1
+         rem (+)= EDB8'8320
+      E
+         rem >>= 1
+   crc_table[i] = rem
+
+F crc32(buf, =crc = UInt32(0))
+   crc = (-)crc
+   L(k) buf
+      crc = (crc >> 8) (+) :crc_table[(crc [&] F'F) (+) k.code]
+   R (-)crc
+
+print(hex(crc32(‘The quick brown fox jumps over the lazy dog’)))

Task/CRC-32/6502-Assembly/crc-32.6502

@@ -0,0 +1,113 @@
+PRHEX	EQU  $FDDA ; <= REPLACE THIS WITH THE PRHEX ROUTINE FOR YOUR MACHINE
+
+string	EQU  $EC
+length	EQU  $EE
+crc0	EQU  $FA
+crc1	EQU  $FB
+crc2	EQU  $FC
+crc3	EQU  $FD
+table0	EQU  $9200
+table1	EQU  $9300
+table2	EQU  $9400
+table3	EQU  $9500
+	ORG  $9114
+	LDA #<text
+	STA  string
+	LDA #>text
+	STA  string+1
+	LDA #$2b ; length of text
+	STA  length
+	LDA #$00
+	STA  length+1
+	STA  crc0
+	STA  crc1
+	STA  crc2
+	STA  crc3
+	JSR  crc32
+	LDA  crc3
+	JSR  PRHEX
+	LDA  crc2
+	JSR  PRHEX
+	LDA  crc1
+	JSR  PRHEX
+	LDA  crc0
+	JMP  PRHEX
+text
+	ASC 'The quick brown fox jumps over the lazy dog'
+	; ORG  $916E
+crc32
+	JSR  start
+	LDY  string
+	STX  string
+loop
+	LDA length
+	BNE no_borrow
+	LDA length+1
+	BEQ ones_complement
+	DEC length+1
+no_borrow
+	DEC length
+	LDA (string),Y
+	EOR  crc0
+	TAX
+	LDA  table0,X
+	EOR  crc1
+	STA  crc0
+	LDA  table1,X
+	EOR  crc2
+	STA  crc1
+	LDA  table2,X
+	EOR  crc3
+	STA  crc2
+	LDA  table3,X
+	STA  crc3
+	INY
+	BNE  loop
+	INC  string+1
+	BNE  loop
+start
+have_table
+	LDX #$00
+	BNE  loop4 ; LDX #$04 BNE ones_complement
+loop256
+	LDA #$00
+	STA  table3,X
+	STA  table2,X
+	STA  table1,X
+	TXA
+	STA  table0,X
+	LDY #$08
+loop8
+	LSR  table3,X
+	ROR  table2,X
+	ROR  table1,X
+	ROR  table0,X
+	BCC  no_xor
+	LDA  table3,X
+	EOR #$ED
+	STA  table3,X
+	LDA  table2,X
+	EOR #$B8
+	STA  table2,X
+	LDA  table1,X
+	EOR #$83
+	STA  table1,X
+	LDA  table0,X
+	EOR #$20
+	STA  table0,X
+no_xor
+	DEY
+	BNE  loop8
+	INX
+	BNE  loop256
+ones_complement
+	LDX #$04
+	STX  have_table+1 ; self-modify
+loop4
+	DEX
+	LDA  crc0,X
+	EOR #$FF
+	STA  crc0,X
+	TXA
+	BNE loop4
+	RTS

Task/CRC-32/ALGOL-68/crc-32.alg

@@ -0,0 +1,54 @@
+[0:255]BITS crc_table;
+BOOL crc_table_computed := FALSE;
+
+PROC make_crc_table = VOID:
+   BEGIN
+      INT n, k;
+      FOR n FROM 0 TO 255 DO
+         BITS c := BIN n;
+         FOR k TO 8 DO
+            c := IF 32 ELEM c THEN
+                    16redb88320 XOR (c SHR 1)
+                 ELSE
+                    c SHR 1
+		 FI
+	 OD;
+	 crc_table[n] := c
+      OD;
+      crc_table_computed := TRUE
+   END;
+
+PROC update_crc = (BITS crc, STRING buf) BITS:
+   BEGIN
+      BITS c := crc XOR 16rffffffff;
+      INT n;
+
+      IF NOT crc_table_computed THEN make_crc_table FI;
+      FOR n TO UPB buf DO
+         c := crc_table[ABS ((c XOR BIN ABS buf[n]) AND 16rff)] XOR (c SHR 8)
+      OD ;
+      c XOR 16rffffffff
+   END;
+
+ PROC hex = (BITS x) STRING :
+   BEGIN
+      PROC hexdig = (BITS x) CHAR: REPR (IF ABS x ≤ 9 THEN ABS x + ABS "0"
+                                         ELSE ABS x - 10 + ABS "a"
+					 FI);
+      STRING h := "";
+      IF x = 16r0 THEN
+	 h := "0"
+      ELSE
+	 BITS n := x;
+	 WHILE h := hexdig (n AND 16rf) + h; n ≠ 16r0 DO
+	    n := n SHR 4
+	 OD
+      FI;
+      h
+   END;
+
+PROC crc = (STRING buf) BITS:
+   update_crc(16r0, buf);
+
+STRING s = "The quick brown fox jumps over the lazy dog";
+print(("CRC32 OF ", s, " is: ", hex (crc (s)), newline))

Task/CRC-32/Ada/crc-32.ada

@@ -0,0 +1,14 @@
+with Ada.Text_IO; use Ada.Text_IO;
+with GNAT.CRC32; use GNAT.CRC32;
+with Interfaces; use Interfaces;
+procedure TestCRC is
+   package IIO is new Ada.Text_IO.Modular_IO (Unsigned_32);
+   crc : CRC32;
+   num : Unsigned_32;
+   str : String := "The quick brown fox jumps over the lazy dog";
+begin
+   Initialize (crc);
+   Update (crc, str);
+   num := Get_Value (crc);
+   IIO.Put (num, Base => 16); New_Line;
+end TestCRC;

Task/CRC-32/Applesoft-BASIC/crc-32-1.basic

@@ -0,0 +1,76 @@
+ 0 DIM D$(1111):D$(0)="0":D$(1)="1":D$(10)="2":D$(11)="3":D$(100)="4":D$(101)="5":D$(110)="6":D$(111)="7":D$(1000)="8":D$(1001)="9":D$(1010)="A":D$(1011)="B":D$(1100)="C":D$(1101)="D":D$(1110)="E":D$(1111)="F"
+ 1 Z$ =  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8)
+ 100 C$ = "00000000000000000000000000000000"
+ 110 S$ = "The quick brown fox jumps over the lazy dog"
+ 120  GOSUB 200"CRC32
+ 130  PRINT D$( VAL ( MID$ (C$,1,4)))D$( VAL ( MID$ (C$,5,4)))D$( VAL ( MID$ (C$,9,4)))D$( VAL ( MID$ (C$,13,4)))D$( VAL ( MID$ (C$,17,4)))D$( VAL ( MID$ (C$,21,4)))D$( VAL ( MID$ (C$,25,4)))D$( VAL ( MID$ (C$,29,4)))"  ";
+ 140  END
+ 200  IF  LEN (S$) = 0 THEN  RETURN
+ 210  GOSUB 280"XOR #$FFFFFFFF
+ 220  FOR I = 1 TO  LEN (S$)
+ 230 R$ = "00000000" +  MID$ (C$,1,24)
+ 235  PRINT D$( VAL ( MID$ (C$,1,4)))D$( VAL ( MID$ (C$,5,4)))D$( VAL ( MID$ (C$,9,4)))D$( VAL ( MID$ (C$,13,4)));
+ 236  PRINT D$( VAL ( MID$ (C$,17,4)))D$( VAL ( MID$ (C$,21,4)))D$( VAL ( MID$ (C$,25,4)))D$( VAL ( MID$ (C$,29,4)))" " MID$ (S$,I,1)Z$;
+ 240 C =  ASC ( MID$ (S$,I,1)):O$ = "": FOR B = 1 TO 8:K =  INT (C / 2):O$ =  STR$ (C - K * 2) + O$:C = K: NEXT B
+ 250 A = ( MID$ (C$,25,1) <  >  MID$ (O$,1,1)) * 128 + ( MID$ (C$,26,1) <  >  MID$ (O$,2,1)) * 64 + ( MID$ (C$,27,1) <  >  MID$ (O$,3,1)) * 32 + ( MID$ (C$,28,1) <  >  MID$ (O$,4,1)) * 16
+ 251 A = ( MID$ (C$,29,1) <  >  MID$ (O$,5,1)) * 8 + ( MID$ (C$,30,1) <  >  MID$ (O$,6,1)) * 4 + ( MID$ (C$,31,1) <  >  MID$ (O$,7,1)) * 2 + ( MID$ (C$,32,1) <  >  MID$ (O$,8,1)) + A: GOSUB 300
+ 260 C$ =  STR$ (( MID$ (R$,1,1) <  >  MID$ (T$,1,1))) +  STR$ (( MID$ (R$,2,1) <  >  MID$ (T$,2,1))) +  STR$ (( MID$ (R$,3,1) <  >  MID$ (T$,3,1))) +  STR$ (( MID$ (R$,4,1) <  >  MID$ (T$,4,1)))
+ 261 C$ = C$ +  STR$ (( MID$ (R$,5,1) <  >  MID$ (T$,5,1))) +  STR$ (( MID$ (R$,6,1) <  >  MID$ (T$,6,1))) +  STR$ (( MID$ (R$,7,1) <  >  MID$ (T$,7,1))) +  STR$ (( MID$ (R$,8,1) <  >  MID$ (T$,8,1)))
+ 262 C$ = C$ +  STR$ (( MID$ (R$,9,1) <  >  MID$ (T$,9,1))) +  STR$ (( MID$ (R$,10,1) <  >  MID$ (T$,10,1))) +  STR$ (( MID$ (R$,11,1) <  >  MID$ (T$,11,1))) +  STR$ (( MID$ (R$,12,1) <  >  MID$ (T$,12,1)))
+ 263 C$ = C$ +  STR$ (( MID$ (R$,13,1) <  >  MID$ (T$,13,1))) +  STR$ (( MID$ (R$,14,1) <  >  MID$ (T$,14,1))) +  STR$ (( MID$ (R$,15,1) <  >  MID$ (T$,15,1))) +  STR$ (( MID$ (R$,16,1) <  >  MID$ (T$,16,1)))
+ 264 C$ = C$ +  STR$ (( MID$ (R$,17,1) <  >  MID$ (T$,17,1))) +  STR$ (( MID$ (R$,18,1) <  >  MID$ (T$,18,1))) +  STR$ (( MID$ (R$,19,1) <  >  MID$ (T$,19,1))) +  STR$ (( MID$ (R$,20,1) <  >  MID$ (T$,20,1)))
+ 265 C$ = C$ +  STR$ (( MID$ (R$,21,1) <  >  MID$ (T$,21,1))) +  STR$ (( MID$ (R$,22,1) <  >  MID$ (T$,22,1))) +  STR$ (( MID$ (R$,23,1) <  >  MID$ (T$,23,1))) +  STR$ (( MID$ (R$,24,1) <  >  MID$ (T$,24,1)))
+ 266 C$ = C$ +  STR$ (( MID$ (R$,25,1) <  >  MID$ (T$,25,1))) +  STR$ (( MID$ (R$,26,1) <  >  MID$ (T$,26,1))) +  STR$ (( MID$ (R$,27,1) <  >  MID$ (T$,27,1))) +  STR$ (( MID$ (R$,28,1) <  >  MID$ (T$,28,1)))
+ 267 C$ = C$ +  STR$ (( MID$ (R$,29,1) <  >  MID$ (T$,29,1))) +  STR$ (( MID$ (R$,30,1) <  >  MID$ (T$,30,1))) +  STR$ (( MID$ (R$,31,1) <  >  MID$ (T$,31,1))) +  STR$ (( MID$ (R$,32,1) <  >  MID$ (T$,32,1)))
+ 270  NEXT I
+ 280 B$ = "": FOR B = 1 TO 32:B$ = B$ +  STR$ (( MID$ (C$,B,1) <  > "1")): NEXT B:C$ = B$
+ 290  RETURN
+ 300  IF  NOT T THEN  DIM T$(255): FOR T = 0 TO 38: READ J: READ T$(J): NEXT T
+ 310  IF  LEN (T$(A)) THEN T$ = T$(A): RETURN
+ 320 R = A:T$ = "": FOR B = 1 TO 8:N =  INT (R / 2):T$ =  MID$ ("01",R - N * 2 + 1,1) + T$:R = N: NEXT B:T$ = "000000000000000000000000" + T$
+ 330  FOR J = 0 TO 7
+ 340 X =  VAL ( MID$ (T$,32,1))
+ 350 T$ = "0" +  MID$ (T$,1,31)
+ 360  IF X THEN B$ = "": FOR B = 1 TO 32:B$ = B$ +  MID$ ("01",( MID$ (T$,B,1) <  >  MID$ ("11101101101110001000001100100000",B,1)) + 1,1): NEXT B:T$ = B$
+ 370  NEXT J
+ 380 T$(A) = T$:T = T + 1
+ 390  RETURN
+ 600  DATA171,01000001000001000111101001100000
+ 610  DATA247,00100011110110010110011110111111
+ 620  DATA95,11111011110101000100110001100101
+ 630  DATA217,11111111000011110110101001110000
+ 640  DATA213,11110110101110010010011001011011
+ 650  DATA179,01010010011010001110001000110110
+ 660  DATA141,10010011000010011111111110011101
+ 670  DATA90,10001011101111101011100011101010
+ 680  DATA224,10100000000010101110001001111000
+ 690  DATA187,01011100101100110110101000000100
+ 700  DATA169,10101111000010100001101101001100
+ 710  DATA60,00101111011011110111110010000111
+ 720  DATA128,11101101101110001000001100100000
+ 730  DATA36,00111100000000111110010011010001
+ 740  DATA235,00110111110110000011101111110000
+ 750  DATA229,11010000011000000001011011110111
+ 760  DATA77,00001000011011010011110100101101
+ 770  DATA167,01001000101100100011011001001011
+ 780  DATA1,01110111000001110011000010010110
+ 790  DATA119,11001110011000011110010010011111
+ 800  DATA96,01001101101100100110000101011000
+ 810  DATA158,00010111101101111011111001000011
+ 820  DATA68,01110001101100011000010110001001
+ 830  DATA56,00101000000000101011100010011110
+ 840  DATA193,11101100011000111111001000100110
+ 850  DATA87,11110101000011111100010001010111
+ 860  DATA160,11010110110101101010001111101000
+ 870  DATA2,11101110000011100110000100101100
+ 880  DATA30,11111010000011110011110101100011
+ 890  DATA7,10011110011001001001010110100011
+ 900  DATA26,11111101011000101111100101111010
+ 910  DATA85,00011011000000011010010101111011
+ 920  DATA15,10010000101111110001110110010001
+ 930  DATA201,11100010101110000111101000010100
+ 940  DATA188,11000010110101111111111110100111
+ 950  DATA0,00000000000000000000000000000000
+ 960  DATA238,01000111101100101100111101111111
+ 970  DATA181,10111011000010110100011100000011
+ 980  DATA114,10111110000010110001000000010000

Task/CRC-32/Applesoft-BASIC/crc-32-2.basic

@@ -0,0 +1,27 @@
+ 0  HIMEM: 37230
+8A=37229:P$=" 'Q$L.L%BP#%GKSFGFB1LEZ*=!4E[-Z=!6EW-[=!TEX-W=!U-XHPR?MPN<!PJ)!7!U7!T7!607!49&^!U+!T+!6+!43 =!UIM7!U=!TI87!T=!6IC7!6=!4I 7!4/POAP;<D2(Q>5ZIYUZ0PV@"
+9FORI=1TOLEN(P$):B$=MID$("D2A0--A6Q4Q5A8Q7Q8Q9R0M6--N3N4N6N8R7O2O4O6S1O7P7S4Q0--S7Q2S9U2X0J6X2X8N1A4G9T8X9U0H3H4Y0X6X7U6U7U8O5V0L5O8O9Y6Z2Z3Z5Z0Z1----J4",(ASC(MID$(P$,I))-32)*2+1,2):POKEA+I,(ASC(MID$(B$,1))-65)*10+ASC(MID$(B$,2))-48:NEXT
+ 100 S$ = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG"
+ 110  FOR I = 2 TO  LEN (S$)
+ 120 C =  ASC ( MID$ (S$,I,1))
+ 130 C$ =  CHR$ (C + 32 * (C >  =  ASC ("A") AND C <  =  ASC ("Z")))
+ 140 S$ =  LEFT$ (S$,I - 1) + C$ +  MID$ (S$,I + 1, LEN (S$) - I)
+ 150  NEXT
+ 155  PRINT  MID$ (S$,1,0 *  FRE (0));
+ 160  POKE 236, PEEK (131)
+ 170  POKE 237, PEEK (132)
+ 180 A =  PEEK (236) +  PEEK (237) * 256
+ 190  POKE 236, PEEK (A + 1)
+ 200  POKE 237, PEEK (A + 2)
+ 210  POKE 238, PEEK (A)
+ 220  POKE 239,0
+ 230  FOR I = 250 TO 253
+ 240  POKE I,0
+ 250  NEXT
+ 260  CALL 37230
+ 270  FOR I = 253 TO 250 STEP  - 1
+ 280 B =  PEEK (I)
+ 290  FOR J = 0 TO 1
+ 300  PRINT  MID$ ("0123456789ABCDEF",B / 16 + 1,1);
+ 310 B = (B -  INT (B / 16) * 16) * 16
+ 320  NEXT J,I

Task/CRC-32/Arturo/crc-32.arturo

@@ -0,0 +1 @@
+print crc "The quick brown fox jumps over the lazy dog"

Task/CRC-32/AutoHotkey/crc-32-1.ahk

@@ -0,0 +1,9 @@
+CRC32(str, enc = "UTF-8")
+{
+    l := (enc = "CP1200" || enc = "UTF-16") ? 2 : 1, s := (StrPut(str, enc) - 1) * l
+    VarSetCapacity(b, s, 0) && StrPut(str, &b, floor(s / l), enc)
+    CRC32 := DllCall("ntdll.dll\RtlComputeCrc32", "UInt", 0, "Ptr", &b, "UInt", s)
+    return Format("{:#x}", CRC32)
+}
+
+MsgBox % CRC32("The quick brown fox jumps over the lazy dog")

Task/CRC-32/AutoHotkey/crc-32-2.ahk

@@ -0,0 +1,16 @@
+CRC32(str)
+{
+    static table := []
+    loop 256 {
+        crc := A_Index - 1
+        loop 8
+            crc := (crc & 1) ? (crc >> 1) ^ 0xEDB88320 : (crc >> 1)
+        table[A_Index - 1] := crc
+    }
+    crc := ~0
+    loop, parse, str
+        crc := table[(crc & 0xFF) ^ Asc(A_LoopField)] ^ (crc >> 8)
+    return Format("{:#x}", ~crc)
+}
+
+MsgBox % CRC32("The quick brown fox jumps over the lazy dog")

Task/CRC-32/C++/crc-32-1.cpp

@@ -0,0 +1,40 @@
+#include <array>
+#include <ranges>
+#include <cstdint>
+#include <numeric>
+#include <concepts>
+#include <algorithm>
+
+// These headers are only needed for main(), to demonstrate.
+#include <iomanip>
+#include <iostream>
+#include <string_view>
+
+inline constexpr auto crc_table = []() {
+    std::array<std::uint32_t, 256> retval{};
+    std::generate(retval.begin(), retval.end(),
+        [n = std::uint32_t{ 0 }]() mutable {
+            auto c = n++;
+            for (std::uint8_t k = 0; k < 8; ++k) {
+                if (c & 1) c = std::uint32_t{ 0xedb88320 } ^ (c >> 1);
+                else c >>= 1;
+            }
+            return c;
+        });
+    return retval;
+}();
+
+
+[[nodiscard]] constexpr std::uint32_t crc(const std::ranges::input_range auto& rng)
+noexcept requires std::convertible_to<std::ranges::range_value_t<decltype(rng)>, std::uint8_t> {
+  return ~std::accumulate(std::ranges::begin(rng), std::ranges::end(rng),
+      ~std::uint32_t{ 0 } & std::uint32_t{ 0xff'ff'ff'ffu },
+        [](std::uint32_t checksum, std::uint8_t value)
+          { return crc_table[(checksum ^ value) & 0xff] ^ (checksum >> 8); });
+}
+
+int main() {
+  constexpr std::string_view str = "The quick brown fox jumps over the lazy dog";
+
+  std::cout << std::hex << std::setw(8) << std::setfill('0') << crc(str) << '\n';
+}

Task/CRC-32/C++/crc-32-2.cpp

@@ -0,0 +1,13 @@
+#include <boost\crc.hpp>
+#include <string>
+#include <iostream>
+
+int main()
+{
+    std::string str( "The quick brown fox jumps over the lazy dog" );
+    boost::crc_32_type  crc;
+    crc.process_bytes( str.data(), str.size() );
+
+    std::cout << "Checksum: " << std::hex << crc.checksum() << std::endl;
+    return 0;
+}

Task/CRC-32/C-sharp/crc-32-1.cs

@@ -0,0 +1,70 @@
+    /// <summary>
+    /// Performs 32-bit reversed cyclic redundancy checks.
+    /// </summary>
+    public class Crc32
+    {
+        #region Constants
+        /// <summary>
+        /// Generator polynomial (modulo 2) for the reversed CRC32 algorithm.
+        /// </summary>
+        private const UInt32 s_generator = 0xEDB88320;
+        #endregion
+
+        #region Constructors
+        /// <summary>
+        /// Creates a new instance of the Crc32 class.
+        /// </summary>
+        public Crc32()
+        {
+            // Constructs the checksum lookup table. Used to optimize the checksum.
+            m_checksumTable = Enumerable.Range(0, 256).Select(i =>
+            {
+                var tableEntry = (uint)i;
+                for (var j = 0; j < 8; ++j)
+                {
+                    tableEntry = ((tableEntry & 1) != 0)
+                        ? (s_generator ^ (tableEntry >> 1))
+                        : (tableEntry >> 1);
+                }
+                return tableEntry;
+            }).ToArray();
+        }
+        #endregion
+
+        #region Methods
+        /// <summary>
+        /// Calculates the checksum of the byte stream.
+        /// </summary>
+        /// <param name="byteStream">The byte stream to calculate the checksum for.</param>
+        /// <returns>A 32-bit reversed checksum.</returns>
+        public UInt32 Get<T>(IEnumerable<T> byteStream)
+        {
+            try
+            {
+                // Initialize checksumRegister to 0xFFFFFFFF and calculate the checksum.
+                return ~byteStream.Aggregate(0xFFFFFFFF, (checksumRegister, currentByte) =>
+                          (m_checksumTable[(checksumRegister & 0xFF) ^ Convert.ToByte(currentByte)] ^ (checksumRegister >> 8)));
+            }
+            catch (FormatException e)
+            {
+                throw new CrcException("Could not read the stream out as bytes.", e);
+            }
+            catch (InvalidCastException e)
+            {
+                throw new CrcException("Could not read the stream out as bytes.", e);
+            }
+            catch (OverflowException e)
+            {
+                throw new CrcException("Could not read the stream out as bytes.", e);
+            }
+        }
+        #endregion
+
+        #region Fields
+        /// <summary>
+        /// Contains a cache of calculated checksum chunks.
+        /// </summary>
+        private readonly UInt32[] m_checksumTable;
+
+        #endregion
+    }

Task/CRC-32/C-sharp/crc-32-2.cs

@@ -0,0 +1,4 @@
+	var arrayOfBytes = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog");
+
+	var crc32 = new Crc32();
+	Console.WriteLine(crc32.Get(arrayOfBytes).ToString("X"));

Task/CRC-32/C/crc-32-1.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <string.h>
+#include <zlib.h>
+
+int main()
+{
+	const char *s = "The quick brown fox jumps over the lazy dog";
+	printf("%lX\n", crc32(0, (const void*)s, strlen(s)));
+
+	return 0;
+}

Task/CRC-32/C/crc-32-2.c

@@ -0,0 +1,48 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+uint32_t
+rc_crc32(uint32_t crc, const char *buf, size_t len)
+{
+	static uint32_t table[256];
+	static int have_table = 0;
+	uint32_t rem;
+	uint8_t octet;
+	int i, j;
+	const char *p, *q;
+
+	/* This check is not thread safe; there is no mutex. */
+	if (have_table == 0) {
+		/* Calculate CRC table. */
+		for (i = 0; i < 256; i++) {
+			rem = i;  /* remainder from polynomial division */
+			for (j = 0; j < 8; j++) {
+				if (rem & 1) {
+					rem >>= 1;
+					rem ^= 0xedb88320;
+				} else
+					rem >>= 1;
+			}
+			table[i] = rem;
+		}
+		have_table = 1;
+	}
+
+	crc = ~crc;
+	q = buf + len;
+	for (p = buf; p < q; p++) {
+		octet = *p;  /* Cast to unsigned octet. */
+		crc = (crc >> 8) ^ table[(crc & 0xff) ^ octet];
+	}
+	return ~crc;
+}
+
+int
+main()
+{
+	const char *s = "The quick brown fox jumps over the lazy dog";
+	printf("%" PRIX32 "\n", rc_crc32(0, s, strlen(s)));
+
+	return 0;
+}

Task/CRC-32/COBOL/crc-32.cobol

@@ -0,0 +1,37 @@
+      *> tectonics: cobc -xj crc32-zlib.cob -lz
+       identification division.
+       program-id. rosetta-crc32.
+
+       environment division.
+       configuration section.
+       repository.
+           function all intrinsic.
+
+       data division.
+       working-storage section.
+       01 crc32-initial        usage binary-c-long.
+       01 crc32-result         usage binary-c-long unsigned.
+       01 crc32-input.
+          05 value "The quick brown fox jumps over the lazy dog".
+       01 crc32-hex            usage pointer.
+
+       procedure division.
+       crc32-main.
+
+      *> libz crc32
+       call "crc32" using
+           by value crc32-initial
+           by reference crc32-input
+           by value length(crc32-input)
+           returning crc32-result
+           on exception
+               display "error: no crc32 zlib linkage" upon syserr
+       end-call
+       call "printf" using "checksum: %lx" & x"0a" by value crc32-result
+
+      *> GnuCOBOL pointers are displayed in hex by default
+       set crc32-hex up by crc32-result
+       display 'crc32 of "' crc32-input '" is ' crc32-hex
+
+       goback.
+       end program rosetta-crc32.

Task/CRC-32/Clojure/crc-32.clj

@@ -0,0 +1,4 @@
+(let [crc (new java.util.zip.CRC32)
+      str "The quick brown fox jumps over the lazy dog"]
+  (. crc update (. str getBytes))
+  (printf "CRC-32('%s') = %s\n" str (Long/toHexString (. crc getValue))))

Task/CRC-32/CoffeeScript/crc-32-1.coffee

@@ -0,0 +1,13 @@
+crc32 = do ->
+  table =
+    for n in [0..255]
+      for [0..7]
+        if n & 1
+          n = 0xEDB88320 ^ n >>> 1
+        else
+          n >>>= 1
+      n
+  (str, crc = -1) ->
+    for c in str
+      crc = crc >>> 8 ^ table[(crc ^ c.charCodeAt 0) & 255]
+    (crc ^ -1) >>> 0

Task/CRC-32/CoffeeScript/crc-32-2.coffee

@@ -0,0 +1 @@
+console.log (crc32 'The quick brown fox jumps over the lazy dog').toString 16

Task/CRC-32/CoffeeScript/crc-32-3.coffee

@@ -0,0 +1 @@
+414fa339

Task/CRC-32/Common-Lisp/crc-32.lisp

@@ -0,0 +1,8 @@
+(ql:quickload :ironclad)
+(defun string-to-digest (str digest)
+  "Return the specified digest for the ASCII string as a hex string."
+  (ironclad:byte-array-to-hex-string
+    (ironclad:digest-sequence digest
+                              (ironclad:ascii-string-to-byte-array str))))
+
+(string-to-digest "The quick brown fox jumps over the lazy dog" :crc32)

Task/CRC-32/Component-Pascal/crc-32.pas

@@ -0,0 +1,12 @@
+MODULE BbtComputeCRC32;
+IMPORT ZlibCrc32,StdLog;
+
+PROCEDURE Do*;
+VAR
+	s: ARRAY 128 OF SHORTCHAR;
+BEGIN	
+	s := "The quick brown fox jumps over the lazy dog";
+	StdLog.IntForm(ZlibCrc32.CRC32(0,s,0,LEN(s$)),16,12,'0',TRUE);
+	StdLog.Ln;
+END Do;
+END BbtComputeCRC32.

Task/CRC-32/Crystal/crc-32.crystal

@@ -0,0 +1,3 @@
+require "digest/crc32";
+
+p Digest::CRC32.checksum("The quick brown fox jumps over the lazy dog").to_s(16)

Task/CRC-32/D/crc-32.d

@@ -0,0 +1,6 @@
+void main() {
+    import std.stdio, std.digest.crc;
+
+    "The quick brown fox jumps over the lazy dog"
+    .crc32Of.crcHexString.writeln;
+}

Task/CRC-32/Delphi/crc-32.delphi

@@ -0,0 +1,15 @@
+program CalcCRC32;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.SysUtils, System.ZLib;
+
+var
+  Data: AnsiString = 'The quick brown fox jumps over the lazy dog';
+  CRC: UInt32;
+
+begin
+  CRC := crc32(0, @Data[1], Length(Data));
+  WriteLn(Format('CRC32 = %8.8X', [CRC]));
+end.

Task/CRC-32/Elixir/crc-32.elixir

@@ -0,0 +1,7 @@
+defmodule Test do
+  def crc32(str) do
+    IO.puts :erlang.crc32(str) |> Integer.to_string(16)
+  end
+end
+
+Test.crc32("The quick brown fox jumps over the lazy dog")

Task/CRC-32/Erlang/crc-32-1.erl

@@ -0,0 +1,4 @@
+-module(crc32).
+-export([test/0]).
+test() ->
+  io:fwrite("~.16#~n",[erlang:crc32(<<"The quick brown fox jumps over the lazy dog">>)]).

Task/CRC-32/Erlang/crc-32-2.erl

@@ -0,0 +1 @@
+16#414FA339

Task/CRC-32/F-Sharp/crc-32-1.fs

@@ -0,0 +1,39 @@
+module Crc32 =
+
+    open System
+
+    // Generator polynomial (modulo 2) for the reversed CRC32 algorithm.
+    let private s_generator = uint32 0xEDB88320
+
+    // Generate lookup table
+    let private lutIntermediate input =
+        if (input &&& uint32 1) <> uint32 0
+        then s_generator ^^^ (input >>> 1)
+        else input >>> 1
+
+    let private lutEntry input =
+        {0..7}
+        |> Seq.fold (fun acc x -> lutIntermediate acc) input
+
+    let private crc32lut =
+        [uint32 0 .. uint32 0xFF]
+        |> List.map lutEntry
+
+    let crc32byte (register : uint32) (byte : byte) =
+        crc32lut.[Convert.ToInt32((register &&& uint32 0xFF) ^^^ Convert.ToUInt32(byte))] ^^^ (register >>> 8)
+
+    // CRC32 of a byte array
+    let crc32 (input : byte[]) =
+        let result = Array.fold crc32byte (uint32 0xFFFFFFFF) input
+        ~~~result
+
+    // CRC32 from ASCII string
+    let crc32OfAscii (inputAscii : string) =
+        let bytes = System.Text.Encoding.ASCII.GetBytes(inputAscii)
+        crc32 bytes
+
+    // Test
+    let testString = "The quick brown fox jumps over the lazy dog"
+    printfn "ASCII Input: %s" testString
+    let result = crc32OfAscii testString
+    printfn "CRC32: 0x%x" result

Task/CRC-32/F-Sharp/crc-32-2.fs

@@ -0,0 +1,2 @@
+ASCII Input: The quick brown fox jumps over the lazy dog
+CRC32: 0x414fa339

Task/CRC-32/FBSL/crc-32.fbsl

@@ -0,0 +1,5 @@
+#APPTYPE CONSOLE
+
+PRINT HEX(CHECKSUM("The quick brown fox jumps over the lazy dog"))
+
+PAUSE

Task/CRC-32/Forth/crc-32.fth

@@ -0,0 +1,11 @@
+: crc/ ( n -- n ) 8 0 do dup 1 rshift swap 1 and if $edb88320 xor then loop ;
+
+: crcfill   256 0 do i crc/ , loop ;
+
+create crctbl crcfill
+
+: crc+ ( crc n -- crc' ) over xor $ff and  cells crctbl + @  swap 8 rshift xor ;
+
+: crcbuf ( crc str len -- crc ) bounds ?do i c@ crc+ loop ;
+
+$ffffffff s" The quick brown fox jumps over the lazy dog" crcbuf $ffffffff xor hex.  bye   \ $414FA339

Task/CRC-32/Fortran/crc-32.f

@@ -0,0 +1,45 @@
+module crc32_m
+    use iso_fortran_env
+    implicit none
+    integer(int32) :: crc_table(0:255)
+contains
+    subroutine update_crc(a, crc)
+        integer :: n, i
+        character(*) :: a
+        integer(int32) :: crc
+
+        crc = not(crc)
+        n = len(a)
+        do i = 1, n
+            crc = ieor(shiftr(crc, 8), crc_table(iand(ieor(crc, iachar(a(i:i))), 255)))
+        end do
+        crc = not(crc)
+    end subroutine
+
+    subroutine init_table
+        integer :: i, j
+        integer(int32) :: k
+
+        do i = 0, 255
+            k = i
+            do j = 1, 8
+                if (btest(k, 0)) then
+                    k = ieor(shiftr(k, 1), -306674912)
+                else
+                    k = shiftr(k, 1)
+                end if
+            end do
+            crc_table(i) = k
+        end do
+    end subroutine
+end module
+
+program crc32
+    use crc32_m
+    implicit none
+    integer(int32) :: crc = 0
+    character(*), parameter :: s = "The quick brown fox jumps over the lazy dog"
+    call init_table
+    call update_crc(s, crc)
+    print "(Z8)", crc
+end program

Task/CRC-32/Free-Pascal-Lazarus/crc-32.pas

@@ -0,0 +1,20 @@
+Program CheckCRC;
+{$IFDEF fpc}{$mode Delphi}{$ENDIF}
+{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}
+uses
+  sysutils,crc;
+
+function CrcString(const mystring: string) : longword;
+var
+  crcvalue: longword;
+begin
+  crcvalue := crc32(0,nil,0);
+  result := crc32(crcvalue, @mystring[1], length(mystring));
+end;
+
+var
+  mytext: string;
+begin
+  myText := 'The quick brown fox jumps over the lazy dog';
+  writeln('crc32 = ', IntToHex(CrcString(mytext), 8));
+end.

Task/CRC-32/FreeBASIC/crc-32.basic

@@ -0,0 +1,50 @@
+' version 18-03-2017
+' compile with: fbc -s console
+
+Function crc32(buf As String) As UInteger<32>
+
+    Static As UInteger<32> table(256)
+    Static As UInteger<32> have_table
+    Dim As UInteger<32> crc, k
+    Dim As ULong i, j
+
+    If have_table = 0 Then
+        For i = 0 To 255
+            k = i
+            For j = 0 To 7
+                If (k And 1) Then
+                    k Shr= 1
+                    k Xor= &Hedb88320
+                Else
+                    k Shr= 1
+                End If
+                table(i) = k
+            Next
+        Next
+        have_table = 1
+    End If
+
+    crc = Not crc ' crc = &Hffffffff
+
+    For i = 0 To Len(buf) -1
+        crc = (crc Shr 8) Xor table((crc And &hff) Xor buf[i])
+    Next
+
+    Return Not crc
+
+End Function
+
+' ------=< MAIN >=------
+
+Dim As String l = "The quick brown fox jumps over the lazy dog"
+Dim As UInteger<32> crc
+
+Print "input = "; l
+print
+Print "The CRC-32 checksum = "; Hex(crc32(l), 8)
+
+' empty keyboard buffer
+While Inkey <> "" : Wend
+Print : Print "hit any key to end program"
+Sleep
+End

Task/CRC-32/Go/crc-32-1.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+    "fmt"
+    "hash/crc32"
+)
+
+func main() {
+    s := []byte("The quick brown fox jumps over the lazy dog")
+    result := crc32.ChecksumIEEE(s)
+    fmt.Printf("%X\n", result)
+}

Task/CRC-32/Go/crc-32-2.go

@@ -0,0 +1,31 @@
+package main
+
+import "fmt"
+
+var table [256]uint32
+
+func init() {
+    for i := range table {
+        word := uint32(i)
+        for j := 0; j < 8; j++ {
+            if word&1 == 1 {
+                word = (word >> 1) ^ 0xedb88320
+            } else {
+                word >>= 1
+            }
+        }
+        table[i] = word
+    }
+}
+
+func crc32(s string) uint32 {
+    crc := ^uint32(0)
+    for i := 0; i < len(s); i++ {
+        crc = table[byte(crc)^s[i]] ^ (crc >> 8)
+    }
+    return ^crc
+}
+
+func main() {
+    fmt.Printf("%0x\n", crc32("The quick brown fox jumps over the lazy dog"))
+}

Task/CRC-32/Groovy/crc-32-1.groovy

@@ -0,0 +1,3 @@
+def crc32(byte[] bytes) {
+    new java.util.zip.CRC32().with { update bytes; value }
+}

Task/CRC-32/Groovy/crc-32-2.groovy

@@ -0,0 +1 @@
+assert '414FA339' == sprintf('%04X', crc32('The quick brown fox jumps over the lazy dog'.bytes))

Task/CRC-32/Haskell/crc-32-1.hs

@@ -0,0 +1,26 @@
+import Data.Bits ((.&.), complement, shiftR, xor)
+import Data.Word (Word32)
+import Numeric (showHex)
+
+crcTable :: Word32 -> Word32
+crcTable = (table !!) . fromIntegral
+  where
+    table = ((!! 8) . iterate xf) <$> [0 .. 255]
+    shifted x = shiftR x 1
+    xf r
+      | r .&. 1 == 1 = xor (shifted r) 0xedb88320
+      | otherwise = shifted r
+
+charToWord :: Char -> Word32
+charToWord = fromIntegral . fromEnum
+
+calcCrc :: String -> Word32
+calcCrc = complement . foldl cf (complement 0)
+  where
+    cf crc x = xor (shiftR crc 8) (crcTable $ xor (crc .&. 0xff) (charToWord x))
+
+crc32 :: String -> String
+crc32 = flip showHex [] . calcCrc
+
+main :: IO ()
+main = putStrLn $ crc32 "The quick brown fox jumps over the lazy dog"

Task/CRC-32/Haskell/crc-32-2.hs

@@ -0,0 +1,13 @@
+import Data.List (genericLength)
+import Numeric (showHex)
+import Foreign.C
+
+foreign import ccall "zlib.h crc32" zlib_crc32 ::
+               CULong -> CString -> CUInt -> CULong
+
+main :: IO ()
+main = do
+  let s = "The quick brown fox jumps over the lazy dog"
+  ptr <- newCString s
+  let r = zlib_crc32 0 ptr (genericLength s)
+  putStrLn $ showHex r ""

Task/CRC-32/Haxe/crc-32.haxe

@@ -0,0 +1,9 @@
+using StringTools;
+
+class Main {
+  static function main() {
+    var data = haxe.io.Bytes.ofString("The quick brown fox jumps over the lazy dog");
+    var crc = haxe.crypto.Crc32.make(data);
+    Sys.println(crc.hex());
+  }
+}

Task/CRC-32/Icon/crc-32.icon

@@ -0,0 +1,33 @@
+link hexcvt,printf
+
+procedure main()
+   s := "The quick brown fox jumps over the lazy dog"
+   a := "414FA339"
+   printf("crc(%i)=%s - implementation is %s\n",
+          s,r := crc32(s),if r == a then "correct" else "in error")
+end
+
+procedure crc32(s)      #: return crc-32 (ISO 3309, ITU-T V.42, Gzip, PNG) of s
+static crcL,mask
+initial {
+   crcL := list(256)                            # crc table
+   p := [0,1,2,4,5,7,8,10,11,12,16,22,23,26]    # polynomial terms
+   mask := 2^32-1                               # word size mask
+   every (poly := 0) := ior(poly,ishift(1,31-p[1 to *p]))
+   every c := n := 0 to *crcL-1 do {            # table
+      every 1 to 8 do
+         c := iand(mask,
+                   if iand(c,1) = 1 then
+                      ixor(poly,ishift(c,-1))
+                   else
+                      ishift(c,-1)
+                  )
+      crcL[n+1] := c
+      }
+   }
+
+   crc := ixor(0,mask)                          # invert bits
+   every crc := iand(mask,
+                     ixor(crcL[iand(255,ixor(crc,ord(!s)))+1],ishift(crc,-8)))
+   return hexstring(ixor(crc,mask))             # return hexstring
+end

Task/CRC-32/J/crc-32-1.j

@@ -0,0 +1,2 @@
+   ((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
+_3199229127

Task/CRC-32/J/crc-32-2.j

@@ -0,0 +1,5 @@
+   (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
+1095738169
+   require'convert'
+   hfd (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
+414FA339

Task/CRC-32/Java/crc-32-1.java

@@ -0,0 +1 @@
+import java.util.zip.CRC32;

Task/CRC-32/Java/crc-32-2.java

@@ -0,0 +1,6 @@
+public static void main(String[] args) throws IOException {
+    String string = "The quick brown fox jumps over the lazy dog";
+    CRC32 crc = new CRC32();
+    crc.update(string.getBytes());
+    System.out.printf("%x", crc.getValue());
+}

Task/CRC-32/JavaScript/crc-32.js

@@ -0,0 +1,98 @@
+(() => {
+    'use strict';
+
+    // --------------------- CRC-32 ----------------------
+
+    // crc32 :: String -> Int
+    const crc32 = str => {
+        // table :: [Int]
+        const table = enumFromTo(0)(255).map(
+            n => take(9)(
+                iterate(
+                    x => (
+                        x & 1 ? (
+                            z => 0xEDB88320 ^ z
+                        ) : identity
+                    )(x >>> 1)
+                )(n)
+            )[8]
+        );
+        return chars(str).reduce(
+            (a, c) => (a >>> 8) ^ table[
+                (a ^ c.charCodeAt(0)) & 255
+            ],
+            -1
+        ) ^ -1;
+    };
+
+    // ---------------------- TEST -----------------------
+    // main :: IO ()
+    const main = () =>
+        showHex(
+            crc32('The quick brown fox jumps over the lazy dog')
+        );
+
+    // --------------------- GENERIC ---------------------
+
+    // chars :: String -> [Char]
+    const chars = s =>
+        s.split('');
+
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = m =>
+        n => !isNaN(m) ? (
+            Array.from({
+                length: 1 + n - m
+            }, (_, i) => m + i)
+        ) : enumFromTo_(m)(n);
+
+
+    // identity :: a -> a
+    const identity = x =>
+        // The identity function.
+        x;
+
+
+    // iterate :: (a -> a) -> a -> Gen [a]
+    const iterate = f =>
+        // An infinite list of repeated
+        // applications of f to x.
+        function* (x) {
+            let v = x;
+            while (true) {
+                yield(v);
+                v = f(v);
+            }
+        };
+
+
+    // showHex :: Int -> String
+    const showHex = n =>
+        // Hexadecimal string for a given integer.
+        '0x' + n.toString(16);
+
+
+    // take :: Int -> [a] -> [a]
+    // take :: Int -> String -> String
+    const take = n =>
+        // The first n elements of a list,
+        // string of characters, or stream.
+        xs => 'GeneratorFunction' !== xs
+        .constructor.constructor.name ? (
+            xs.slice(0, n)
+        ) : [].concat.apply([], Array.from({
+            length: n
+        }, () => {
+            const x = xs.next();
+            return x.done ? [] : [x.value];
+        }));
+
+
+    // MAIN -------------
+    const result = main();
+    return (
+        console.log(result),
+        result
+    );
+})();

Task/CRC-32/Jsish/crc-32.jsish

@@ -0,0 +1 @@
+# Util.crc32('The quick brown fox jumps over the lazy dog').toString(16);

Task/CRC-32/Julia/crc-32-1.julia

@@ -0,0 +1,2 @@
+using Libz
+println(string(Libz.crc32(UInt8.(b"The quick brown fox jumps over the lazy dog")), base=16))

Task/CRC-32/Julia/crc-32-2.julia

@@ -0,0 +1,31 @@
+function crc32(crc::Int, str::String)
+    table = zeros(UInt32, 256)
+
+    for i in 0:255
+        tmp = i
+        for j in 0:7
+            if tmp & 1 == 1
+                tmp >>= 1
+                tmp ⊻= 0xedb88320
+            else
+                tmp >>= 1
+            end
+        end
+
+        table[i + 1] = tmp
+    end
+
+    crc ⊻= 0xffffffff
+
+    for i in UInt32.(collect(str))
+        crc = (crc >> 8) ⊻ table[(crc & 0xff) ⊻ i + 1]
+    end
+
+    crc ⊻ 0xffffffff
+end
+
+str = "The quick brown fox jumps over the lazy dog"
+crc = crc32(0, str)
+assert(crc == 0x414fa339)
+println("Message: ", str)
+println("Checksum: ", hex(crc))

Task/CRC-32/Kotlin/crc-32.kotlin

@@ -0,0 +1,12 @@
+// version 1.0.6
+
+import java.util.zip.CRC32
+
+fun main(args: Array<String>) {
+    val text = "The quick brown fox jumps over the lazy dog"
+    val crc = CRC32()
+    with (crc) {
+        update(text.toByteArray())
+        println("The CRC-32 checksum of '$text' = ${"%x".format(value)}")
+    }
+}

Task/CRC-32/Lingo/crc-32-1.lingo

@@ -0,0 +1,9 @@
+crcObj = script("CRC").new()
+
+crc32 = crcObj.crc32("The quick brown fox jumps over the lazy dog")
+
+put crc32
+-- <ByteArrayObject length = 4 ByteArray = 0x41, 0x4f, 0xa3, 0x39 >
+
+put crc32.toHexString(1, crc32.length)
+-- "41 4f a3 39"

Task/CRC-32/Lingo/crc-32-2.lingo

@@ -0,0 +1,67 @@
+--****************************************************************************
+-- @desc      CRC-32 Class
+-- @file      parent script "CRC"
+-- @version   0.1
+--****************************************************************************
+
+property _CRC32Table
+
+----------------------------------------
+-- @constructor
+----------------------------------------
+on new me
+
+  -- used for fast CRC32 calculation
+  me._CRC32Table = [\
+  0, 1996959894, -301047508, -1727442502, 124634137, 1886057615, -379345611, -1637575261, 249268274, 2044508324,\
+  -522852066, -1747789432, 162941995, 2125561021, -407360249, -1866523247, 498536548, 1789927666, -205950648,\
+  -2067906082, 450548861, 1843258603, -187386543, -2083289657, 325883990, 1684777152, -43845254, -1973040660,\
+  335633487, 1661365465, -99664541, -1928851979, 997073096, 1281953886, -715111964, -1570279054, 1006888145,\
+  1258607687, -770865667, -1526024853, 901097722, 1119000684, -608450090, -1396901568, 853044451, 1172266101,\
+  -589951537, -1412350631, 651767980, 1373503546, -925412992, -1076862698, 565507253, 1454621731, -809855591,\
+  -1195530993, 671266974, 1594198024, -972236366, -1324619484, 795835527, 1483230225, -1050600021, -1234817731,\
+  1994146192, 31158534, -1731059524, -271249366, 1907459465, 112637215, -1614814043, -390540237, 2013776290,\
+  251722036, -1777751922, -519137256, 2137656763, 141376813, -1855689577, -429695999, 1802195444, 476864866,\
+  -2056965928, -228458418, 1812370925, 453092731, -2113342271, -183516073, 1706088902, 314042704, -1950435094,\
+  -54949764, 1658658271, 366619977, -1932296973, -69972891, 1303535960, 984961486, -1547960204, -725929758,\
+  1256170817, 1037604311, -1529756563, -740887301, 1131014506, 879679996, -1385723834, -631195440, 1141124467,\
+  855842277, -1442165665, -586318647, 1342533948, 654459306, -1106571248, -921952122, 1466479909, 544179635,\
+  -1184443383, -832445281, 1591671054, 702138776, -1328506846, -942167884, 1504918807, 783551873, -1212326853,\
+  -1061524307, -306674912, -1698712650, 62317068, 1957810842, -355121351, -1647151185, 81470997, 1943803523,\
+  -480048366, -1805370492, 225274430, 2053790376, -468791541, -1828061283, 167816743, 2097651377, -267414716,\
+  -2029476910, 503444072, 1762050814, -144550051, -2140837941, 426522225, 1852507879, -19653770, -1982649376,\
+  282753626, 1742555852, -105259153, -1900089351, 397917763, 1622183637, -690576408, -1580100738, 953729732,\
+  1340076626, -776247311, -1497606297, 1068828381, 1219638859, -670225446, -1358292148, 906185462, 1090812512,\
+  -547295293, -1469587627, 829329135, 1181335161, -882789492, -1134132454, 628085408, 1382605366, -871598187,\
+  -1156888829, 570562233, 1426400815, -977650754, -1296233688, 733239954, 1555261956, -1026031705, -1244606671,\
+  752459403, 1541320221, -1687895376, -328994266, 1969922972, 40735498, -1677130071, -351390145, 1913087877,\
+  83908371, -1782625662, -491226604, 2075208622, 213261112, -1831694693, -438977011, 2094854071, 198958881,\
+  -2032938284, -237706686, 1759359992, 534414190, -2118248755, -155638181, 1873836001, 414664567, -2012718362,\
+  -15766928, 1711684554, 285281116, -1889165569, -127750551, 1634467795, 376229701, -1609899400, -686959890,\
+  1308918612, 956543938, -1486412191, -799009033, 1231636301, 1047427035, -1362007478, -640263460, 1088359270,\
+  936918000, -1447252397, -558129467, 1202900863, 817233897, -1111625188, -893730166, 1404277552, 615818150,\
+  -1160759803, -841546093, 1423857449, 601450431, -1285129682, -1000256840, 1567103746, 711928724, -1274298825,\
+  -1022587231, 1510334235, 755167117]
+  return me
+end
+
+----------------------------------------
+-- Calculates CRC-32 checksum of string or bytearray
+-- @param {bytearray|string} input
+-- @return {bytearray} (4 bytes)
+----------------------------------------
+on crc32 (me, input)
+  if stringP(input) then input = bytearray(input)
+  crc = -1
+  len = input.length
+  repeat with i = 1 to len
+    if (crc>0) then bitShift8 = crc/256
+    else bitShift8 = bitAnd(crc,2147483647)/256+8388608
+    crc = bitXor(bitShift8,me._CRC32Table[bitAnd(bitXor(crc,input[i]),255)+1])
+  end repeat
+  ba = bytearray()
+  ba.endian = #bigEndian
+  ba.writeInt32(bitXOr(crc,-1))
+  ba.position = 1
+  return ba
+end

Task/CRC-32/Lingo/crc-32-3.lingo

@@ -0,0 +1,3 @@
+cx = Xtra("Crypto").new()
+put cx.cx_crc32_string("The quick brown fox jumps over the lazy dog")
+-- "414fa339"

Task/CRC-32/Lua/crc-32-1.lua

@@ -0,0 +1,3 @@
+local compute=require"zlib".crc32()
+local sum=compute("The quick brown fox jumps over the lazy dog")
+print(string.format("0x%x", sum))

Task/CRC-32/Lua/crc-32-2.lua

@@ -0,0 +1,34 @@
+function crc32(buf, size)
+  local crc = 0xFFFFFFFF
+  local table = {}
+  local rem, c
+
+  -- calculate CRC-table
+  for i = 0, 0xFF do
+    rem = i
+    for j = 1, 8 do
+      if (rem & 1 == 1) then
+        rem = rem >> 1
+        rem = rem ~ 0xEDB88320
+      else
+        rem = rem >> 1
+      end
+    end
+    table[i] = rem
+  end
+
+  for x = 1, size do
+    c = buf[x]
+    crc = (crc >> 8) ~ table[(crc & 0xFF) ~ c]
+  end
+  return crc ~ 0xFFFFFFFF
+end
+
+
+local str = "The quick brown fox jumps over the lazy dog"
+local t = {}
+for i = 1, #str do
+  t[i] = str:byte(i)
+end
+
+print(string.format("CRC32: %x", crc32(t,#str)))

Task/CRC-32/M2000-Interpreter/crc-32-1.m2000

@@ -0,0 +1,25 @@
+Module CheckIt {
+      Function PrepareTable {
+            Dim Base 0, table(256)
+            For i = 0 To 255 {
+                    k = i
+                    For j = 0 To 7 {
+                              If binary.and(k,1)=1 Then {
+                                  k =binary.Xor(binary.shift(k, -1) ,  0xEDB88320)
+                              }  Else k=binary.shift(k, -1)
+                    }
+                    table(i) = k
+             }
+             =table()
+      }
+      crctable=PrepareTable()
+      crc32= lambda crctable (buf$) -> {
+                crc =0xFFFFFFFF
+                For i = 0 To Len(buf$) -1
+                     crc = binary.xor(binary.shift(crc, -8), array(crctable, binary.xor(binary.and(crc, 0xff), asc(mid$(buf$, i+1, 1)))))
+                Next i
+                =0xFFFFFFFF-crc
+      }
+      Print crc32("The quick brown fox jumps over the lazy dog")=0x414fa339
+}
+CheckIt

Task/CRC-32/M2000-Interpreter/crc-32-2.m2000

@@ -0,0 +1,7 @@
+Module CheckApi {
+      Declare CRC32 LIB "ntdll.RtlComputeCrc32" {Long Zero, a$, long s}
+      a$=Str$("The quick brown fox jumps over the lazy dog")
+      l=len(a$)*2
+      Hex Uint(CRC32(0,a$,l))
+}
+CheckApi

Task/CRC-32/Mathematica/crc-32.math

@@ -0,0 +1,6 @@
+type="CRC32"; (*pick one out of 13 predefined hash types*)
+StringForm[
+"The "<>type<>" hash code of \"``\" is ``.",
+s="The quick brown fox jumps over the lazy dog",
+Hash[s,type,"HexString"]
+]

Task/CRC-32/NOWUT/crc-32.nowut

@@ -0,0 +1,63 @@
+; link with PIOxxx.OBJ
+
+        sectionbss
+
+crctable.d:     resd 256
+
+        sectiondata
+
+havetable.b:    db 0
+string:         db "The quick brown fox jumps over the lazy dog"
+stringend:
+                db 13,10,0        ; carriage return and null terminator
+
+        sectioncode
+
+start!
+        gosub initplatform
+
+        beginfunc
+        localvar crc.d
+
+        callex ,printnt,"input = ".a
+        callex ,printnt,string
+
+        callex ,printnt,"The CRC-32 checksum = ".a
+        callex crc,crc32,string,stringend
+        callex ,printhexr,crc
+
+        endfunc
+        end
+
+crc32:
+        beginfunc bufend.d,buf.d
+        localvar i.d,j.d,k.d,k2.d,crc.d
+
+        ifunequal havetable,0,tabledone
+        i=0
+        whileless i,256
+
+        k=i > j=8
+        countdown j
+        k2=k > k=_ shr 1
+        ifequal k2 and 1,0,noxor > k=_ xor $EDB88320
+noxor:
+        nextcount
+
+        crctable(i shl 2)=k
+        i=_+1
+        wend
+
+        havetable=1
+tabledone:
+
+        crc=-1
+
+        whileless buf,bufend
+        crc=_ shr 8 xor crctable(crc and $FF xor [buf].b shl 2)
+        buf=_+1
+        wend
+
+        crc=_ xor -1
+        endfunc crc
+        returnex 8                        ; clean off 2 parameters from the stack

Task/CRC-32/Neko/crc-32.neko

@@ -0,0 +1,12 @@
+/**
+ <doc>CRC32 in Neko</doc>
+**/
+
+var int32_new = $loader.loadprim("std@int32_new", 1)
+var update_crc32 = $loader.loadprim("zlib@update_crc32", 4)
+
+var crc = int32_new(0)
+var txt = "The quick brown fox jumps over the lazy dog"
+
+crc = update_crc32(crc, txt, 0, $ssize(txt))
+$print(crc, "\n")

Task/CRC-32/NetRexx/crc-32.netrexx

@@ -0,0 +1,11 @@
+/* NetRexx */
+options replace format comments java crossref symbols binary
+
+import java.util.zip.CRC32
+
+toBeEncoded = String("The quick brown fox jumps over the lazy dog")
+myCRC = CRC32()
+myCRC.update(toBeEncoded.getBytes())
+say "The CRC-32 value is :" Long.toHexString(myCRC.getValue()) "!"
+
+return

Task/CRC-32/Nim/crc-32.nim

@@ -0,0 +1,23 @@
+import strutils
+
+type TCrc32* = uint32
+const InitCrc32* = TCrc32(0xffffffff)
+
+proc createCrcTable(): array[0..255, TCrc32] =
+  for i in 0..255:
+    var rem = TCrc32(i)
+    for j in 0..7:
+      if (rem and 1) > 0: rem = (rem shr 1) xor TCrc32(0xedb88320)
+      else: rem = rem shr 1
+    result[i] = rem
+
+# Table created at compile time
+const crc32table = createCrcTable()
+
+proc crc32(s: string): TCrc32 =
+  result = InitCrc32
+  for c in s:
+    result = (result shr 8) xor crc32table[(result and 0xff) xor byte(c)]
+  result = not result
+
+echo crc32("The quick brown fox jumps over the lazy dog").int64.toHex(8)

Task/CRC-32/OCaml/crc-32.ocaml

@@ -0,0 +1,4 @@
+let () =
+  let s = "The quick brown fox jumps over the lazy dog" in
+  let crc = Zlib.update_crc 0l s 0 (String.length s) in
+  Printf.printf "crc: %lX\n" crc

Task/CRC-32/Oberon/crc-32.oberon

@@ -0,0 +1,11 @@
+MODULE CRC32;
+IMPORT
+  NPCT:Zlib,
+  Strings,
+  Out;
+VAR
+  s: ARRAY 128 OF CHAR;
+BEGIN
+  COPY("The quick brown fox jumps over the lazy dog",s);
+  Out.Hex(Zlib.CRC32(0,s,0,Strings.Length(s)),0);Out.Ln
+END CRC32.

Task/CRC-32/Objeck/crc-32.objeck

@@ -0,0 +1,5 @@
+class CRC32 {
+  function : Main(args : String[]) ~ Nil {
+    "The quick brown fox jumps over the lazy dog"->ToByteArray()->CRC32()->PrintLine();
+  }
+}

Task/CRC-32/Ol/crc-32.ol

@@ -0,0 +1,18 @@
+(define (crc32 str)
+   (bxor #xFFFFFFFF
+      (fold (lambda (crc char)
+               (let loop ((n 8) (crc crc) (bits char))
+                  (if (eq? n 0)
+                     crc
+                     (let*((flag (band (bxor bits crc) 1))
+                           (crc (>> crc 1))
+                           (crc (if (eq? flag 0) crc (bxor crc #xEDB88320)))
+                           (bits (>> bits 1)))
+                        (loop (- n 1) crc bits)))))
+         #xFFFFFFFF
+         (string->list str))))
+
+(print (number->string (crc32 "The quick brown fox jumps over the lazy dog") 16))
+(print (number->string (crc32 (list->string (repeat #x00 32))) 16))
+(print (number->string (crc32 (list->string (repeat #xFF 32))) 16))
+(print (number->string (crc32 (list->string (iota 32))) 16))

Task/CRC-32/OoRexx/crc-32.rexx

@@ -0,0 +1,9 @@
+/* ooRexx */
+clzCRC32=bsf.importClass("java.util.zip.CRC32")
+myCRC32 =clzCRC32~new
+toBeEncoded="The quick brown fox jumps over the lazy dog"
+myCRC32~update(BsfRawBytes(toBeEncoded))
+numeric digits 20
+say 'The CRC-32 value of "'toBeEncoded'" is:' myCRC32~getValue~d2x
+
+::requires "BSF.CLS"    -- get Java bridge

Task/CRC-32/PARI-GP/crc-32.parigp

@@ -0,0 +1,3 @@
+install("crc32", "lLsL", "crc32", "libz.so");
+s = "The quick brown fox jumps over the lazy dog";
+printf("%0x\n", crc32(0, s, #s))

Task/CRC-32/PHP/crc-32.php

@@ -0,0 +1 @@
+printf("%x\n", crc32("The quick brown fox jumps over the lazy dog"));

Task/CRC-32/PL-I/crc-32.pli

@@ -0,0 +1,98 @@
+*process source attributes xref or(!) nest;
+ crct: Proc Options(main);
+ /*********************************************************************
+ * 19.08.2013 Walter Pachl  derived from REXX
+ *********************************************************************/
+ Dcl (LEFT,LENGTH,RIGHT,SUBSTR,UNSPEC) Builtin;
+ Dcl SYSPRINT Print;
+ dcl tab(0:255) Bit(32);
+ Call mk_tab;
+ Call crc_32('The quick brown fox jumps over the lazy dog');
+ Call crc_32('Generate CRC32 Checksum For Byte Array Example');
+
+ crc_32: Proc(s);
+ /*********************************************************************
+ * compute checksum for s
+ *********************************************************************/
+ Dcl s Char(*);
+ Dcl d   Bit(32);
+ Dcl d1  Bit( 8);
+ Dcl d2  Bit(24);
+ Dcl cc  Char(1);
+ Dcl ccb Bit(8);
+ Dcl tib Bit(8);
+ Dcl ti  Bin Fixed(16) Unsigned;
+ Dcl k   Bin Fixed(16) Unsigned;
+ d=(32)'1'b;
+ Do k=1 To length(s);
+    d1=right(d,8);
+    d2=left(d,24);
+    cc=substr(s,k,1);
+    ccb=unspec(cc);
+    tib=d1^ccb;
+    Unspec(ti)=tib;
+    d='00000000'b!!d2^tab(ti);
+    End;
+  d=d^(32)'1'b;
+  Put Edit(s,'CRC_32=',b2x(d))(Skip,a(50),a,a);
+  Put Edit('decimal ',b2d(d))(skip,x(49),a,f(10));
+ End;
+
+ b2x: proc(b) Returns(char(8));
+ dcl b bit(32);
+ dcl b4 bit(4);
+ dcl i Bin Fixed(31);
+ dcl r Char(8) Var init('');
+ Do i=1 To 29 By 4;
+   b4=substr(b,i,4);
+   Select(b4);
+     When('0000'b) r=r!!'0';
+     When('0001'b) r=r!!'1';
+     When('0010'b) r=r!!'2';
+     When('0011'b) r=r!!'3';
+     When('0100'b) r=r!!'4';
+     When('0101'b) r=r!!'5';
+     When('0110'b) r=r!!'6';
+     When('0111'b) r=r!!'7';
+     When('1000'b) r=r!!'8';
+     When('1001'b) r=r!!'9';
+     When('1010'b) r=r!!'A';
+     When('1011'b) r=r!!'B';
+     When('1100'b) r=r!!'C';
+     When('1101'b) r=r!!'D';
+     When('1110'b) r=r!!'E';
+     When('1111'b) r=r!!'F';
+     End;
+   End;
+ Return(r);
+ End;
+
+ b2d: Proc(b) Returns(Dec Fixed(15));
+ Dcl b Bit(32);
+ Dcl r Dec Fixed(15) Init(0);
+ Dcl i Bin Fixed(16);
+ Do i=1 To 32;
+   r=r*2
+   If substr(b,i,1) Then
+     r=r+1;
+   End;
+ Return(r);
+ End;
+
+ mk_tab: Proc;
+ dcl b32 bit(32);
+ dcl lb  bit( 1);
+ dcl ccc bit(32) Init('edb88320'bx);
+ dcl (i,j) Bin Fixed(15);
+ Do i=0 To 255;
+   b32=(24)'0'b!!unspec(i);
+   Do j=0 To 7;
+     lb=right(b32,1);
+     b32='0'b!!left(b32,31);
+     If lb='1'b Then
+       b32=b32^ccc;
+     End;
+   tab(i)=b32;
+   End;
+ End;
+ End;

Task/CRC-32/Perl/crc-32.pl

@@ -0,0 +1,9 @@
+#!/usr/bin/perl
+use 5.010 ;
+use strict ;
+use warnings ;
+use Digest::CRC qw( crc32 ) ;
+
+my $crc = Digest::CRC->new( type => "crc32" ) ;
+$crc->add ( "The quick brown fox jumps over the lazy dog" )  ;
+say "The checksum is " . $crc->hexdigest( ) ;

Task/CRC-32/Phix/crc-32.phix

@@ -0,0 +1,37 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">table</span>
+ <span style="color: #004080;">bool</span> <span style="color: #000000;">have_table</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">crc32</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">have_table</span> <span style="color: #008080;">then</span>
+         <span style="color: #000000;">have_table</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>
+         <span style="color: #000000;">table</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">256</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">255</span> <span style="color: #008080;">do</span>
+             <span style="color: #004080;">atom</span> <span style="color: #000000;">rem</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span>
+             <span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">8</span> <span style="color: #008080;">do</span>
+                 <span style="color: #008080;">if</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rem</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
+                     <span style="color: #000000;">rem</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rem</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span><span style="color: #000000;">#EDB88320</span><span style="color: #0000FF;">)</span>
+                 <span style="color: #008080;">else</span>
+                     <span style="color: #000000;">rem</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rem</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
+                 <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+                 <span style="color: #008080;">if</span> <span style="color: #000000;">rem</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+                     <span style="color: #000000;">rem</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">#100000000</span>
+                 <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+             <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+             <span style="color: #000000;">table</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">rem</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #004080;">atom</span> <span style="color: #000000;">crc</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">#FFFFFFFF</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">crc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">crc</span><span style="color: #0000FF;">/</span><span style="color: #000000;">#100</span><span style="color: #0000FF;">),</span><span style="color: #000000;">table</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">crc</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0xff</span><span style="color: #0000FF;">),</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">crc</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+             <span style="color: #000000;">crc</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">#100000000</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">not_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">crc</span><span style="color: #0000FF;">),</span><span style="color: #000000;">#FFFFFFFF</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"The quick brown fox jumps over the lazy dog"</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The CRC of %s is %08x\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">crc32</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)})</span>
+<!--

Task/CRC-32/PicoLisp/crc-32.l

@@ -0,0 +1,27 @@
+(setq *Table
+   (mapcar
+      '((N)
+         (do 8
+            (setq N
+               (if (bit? 1 N)
+                  (x| (>> 1 N) `(hex "EDB88320"))
+                  (>> 1 N) ) ) ) )
+      (range 0 255) ) )
+
+(de crc32 (Lst)
+   (let Crc `(hex "FFFFFFFF")
+      (for I (chop Lst)
+         (setq Crc
+            (x|
+               (get
+                  *Table
+                  (inc (x| (& Crc 255) (char I))) )
+               (>> 8 Crc) ) ) )
+      (x| `(hex "FFFFFFFF") Crc) ) )
+
+(let Str "The quick brown fox jumps over the lazy dog"
+   (println (hex (crc32 Str)))
+   (println
+      (hex (native "libz.so" "crc32" 'N 0 Str (length Str))) ) )
+
+(bye)

Task/CRC-32/Pike/crc-32.pike

@@ -0,0 +1,2 @@
+string foo = "The quick brown fox jumps over the lazy dog";
+write("0x%x\n", Gz.crc32(foo));

Task/CRC-32/PowerBASIC/crc-32.basic

@@ -0,0 +1,48 @@
+#COMPILE EXE
+#DIM ALL
+#COMPILER PBCC 6
+
+' ***********
+
+FUNCTION CRC32(BYVAL p AS BYTE PTR, BYVAL NumBytes AS DWORD) AS DWORD
+  STATIC LUT() AS DWORD
+  LOCAL i, j, k, crc AS DWORD
+
+  IF ARRAYATTR(LUT(), 0) = 0 THEN
+    REDIM LUT(0 TO 255)
+    FOR i = 0 TO 255
+      k = i
+      FOR j = 0 TO 7
+        IF (k AND 1) THEN
+          SHIFT RIGHT k, 1
+          k XOR= &HEDB88320
+        ELSE
+          SHIFT RIGHT k, 1
+        END IF
+      NEXT j
+      LUT(i) = k
+    NEXT i
+  END IF
+
+  crc = &HFFFFFFFF
+
+  FOR i = 0 TO NumBytes - 1
+    k = (crc AND &HFF& XOR @p[i])
+    SHIFT RIGHT crc, 8
+    crc XOR= LUT(k)
+  NEXT i
+
+  FUNCTION = NOT crc
+END FUNCTION
+
+' ***********
+
+FUNCTION PBMAIN () AS LONG
+  LOCAL s AS STRING
+  LOCAL crc AS DWORD
+
+  s = "The quick brown fox jumps over the lazy dog"
+  CON.PRINT "Text:  " & s
+  crc = CRC32(STRPTR(s), LEN(s))
+  CON.PRINT "CRC32: " & HEX$(crc)
+END FUNCTION

Task/CRC-32/PureBasic/crc-32.basic

@@ -0,0 +1,10 @@
+a$="The quick brown fox jumps over the lazy dog"
+
+UseCRC32Fingerprint() : b$=StringFingerprint(a$, #PB_Cipher_CRC32)
+
+OpenConsole()
+PrintN("CRC32 Cecksum [hex] = "+UCase(b$))
+PrintN("CRC32 Cecksum [dec] = "+Val("$"+b$))
+Input()
+
+End

Task/CRC-32/Python/crc-32-1.py

@@ -0,0 +1,8 @@
+>>> s = 'The quick brown fox jumps over the lazy dog'
+>>> import zlib
+>>> hex(zlib.crc32(s))
+'0x414fa339'
+
+>>> import binascii
+>>> hex(binascii.crc32(s))
+'0x414fa339'

Task/CRC-32/Python/crc-32-2.py

@@ -0,0 +1,19 @@
+def create_table():
+    a = []
+    for i in range(256):
+        k = i
+        for j in range(8):
+            if k & 1:
+                k ^= 0x1db710640
+            k >>= 1
+        a.append(k)
+    return a
+
+def crc_update(buf, crc):
+    crc ^= 0xffffffff
+    for k in buf:
+        crc = (crc >> 8) ^ crc_table[(crc & 0xff) ^ k]
+    return crc ^ 0xffffffff
+
+crc_table = create_table()
+print(hex(crc_update(b"The quick brown fox jumps over the lazy dog", 0)))

Task/CRC-32/Python/crc-32-3.py

@@ -0,0 +1,64 @@
+'''CRC-32 checksums for ascii strings'''
+
+from functools import (reduce)
+from itertools import (islice)
+
+
+# crc32 :: String -> Int
+def crc32(s):
+    '''CRC-32 checksum for an ASCII encoded string'''
+    def go(x):
+        x2 = x >> 1
+        return 0xedb88320 ^ x2 if x & 1 else x2
+    table = [
+        index(iterate(go)(n))(8)
+        for n in range(0, 256)
+    ]
+    return reduce(
+        lambda a, c: (a >> 8) ^ table[
+            (a ^ ord(c)) & 0xff
+        ],
+        s,
+        (0xffffffff)
+    ) ^ 0xffffffff
+
+
+# ------------------------- TEST -------------------------
+# main :: IO ()
+def main():
+    '''Test'''
+    print(
+        format(
+            crc32('The quick brown fox jumps over the lazy dog'),
+            '02x'
+        )
+    )
+
+
+# ----------------------- GENERIC ------------------------
+
+# index (!!) :: [a] -> Int -> a
+def index(xs):
+    '''Item at given (zero-based) index.'''
+    return lambda n: None if 0 > n else (
+        xs[n] if (
+            hasattr(xs, "__getitem__")
+        ) else next(islice(xs, n, None))
+    )
+
+
+# iterate :: (a -> a) -> a -> Gen [a]
+def iterate(f):
+    '''An infinite list of repeated
+       applications of f to x.
+    '''
+    def go(x):
+        v = x
+        while True:
+            yield v
+            v = f(v)
+    return go
+
+
+if __name__ == '__main__':
+    main()

Task/CRC-32/QB64/crc-32.qb64

@@ -0,0 +1,32 @@
+PRINT HEX$(crc32("The quick brown fox jumps over the lazy dog"))
+
+FUNCTION crc32~& (buf AS STRING)
+    STATIC table(255) AS _UNSIGNED LONG
+    STATIC have_table AS _BYTE
+    DIM crc AS _UNSIGNED LONG, k AS _UNSIGNED LONG
+    DIM i AS LONG, j AS LONG
+
+    IF have_table = 0 THEN
+        FOR i = 0 TO 255
+            k = i
+            FOR j = 0 TO 7
+                IF (k AND 1) THEN
+                    k = _SHR(k, 1)
+                    k = k XOR &HEDB88320
+                ELSE
+                    k = _SHR(k, 1)
+                END IF
+                table(i) = k
+            NEXT
+        NEXT
+        have_table = -1
+    END IF
+
+    crc = NOT crc ' crc = &Hffffffff
+
+    FOR i = 1 TO LEN(buf)
+        crc = (_SHR(crc, 8)) XOR table((crc AND &HFF) XOR ASC(buf, i))
+    NEXT
+
+    crc32~& = NOT crc
+END FUNCTION

Task/CRC-32/Quackery/crc-32.quackery

@@ -0,0 +1,20 @@
+  [ table ]                      is crctable ( n --> n )
+
+  256 times
+    [ i^ 8 times
+      [ dup 1 >>
+        swap 1 & if
+          [ hex EDB88320 ^ ] ]
+     ' crctable put ]
+
+  [ hex FFFFFFFF swap
+    witheach
+      [ over ^ hex FF &
+        crctable
+        swap 8 >> ^ ]
+     hex FFFFFFFF ^ ]            is crc-32   ( [ --> n )
+
+  $ "The quick brown fox jumps over the lazy dog" crc-32
+  16 base put
+  echo
+  base release

Task/CRC-32/R/crc-32.r

@@ -0,0 +1 @@
+digest("The quick brown fox jumps over the lazy dog","crc32", serialize=F)

Task/CRC-32/REXX/crc-32.rexx

@@ -0,0 +1,31 @@
+/*REXX program computes the  CRC─32  (32 bit Cyclic Redundancy Check)  checksum  for a  */
+/*─────────────────────────────────given string  [as described in ISO 3309, ITU─T V.42].*/
+call show  'The quick brown fox jumps over the lazy dog'               /*the 1st string.*/
+call show  'Generate CRC32 Checksum For Byte Array Example'            /* "  2nd    "   */
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+CRC_32: procedure; parse arg !,$; c= 'edb88320'x /*2nd arg used for repeated invocations*/
+                                  f= 'ffFFffFF'x /* [↓]  build an  8─bit  indexed table,*/
+          do i=0  for 256;        z= d2c(i)      /*                  one byte at a time.*/
+          r= right(z, 4, '0'x)                   /*insure the  "R"   is thirty─two bits.*/
+                                                 /* [↓]  handle each rightmost byte bit.*/
+            do j=0  for 8;       rb= x2b(c2x(r)) /*handle each bit of rightmost 8 bits. */
+            r= x2c( b2x(0 || left(rb, 31) ) )    /*shift it right (an unsigned)  1  bit.*/
+            if right(rb,1)  then r= bitxor(r, c) /*this is a bin bit for XOR grunt─work.*/
+            end    /*j*/
+          !.z= r                                 /*assign to an eight─bit index table.  */
+          end      /*i*/
+        $=bitxor( word($ '0000000'x, 1), f)      /*utilize the user's CRC or a default. */
+          do k=1  for length(!  )                /*start number crunching the input data*/
+          ?= bitxor(right($,1),  substr(!,k,1) )
+          $= bitxor('0'x || left($, 3),  !.?)
+          end   /*k*/
+        return $                                 /*return with cyclic redundancy check. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+show:   procedure;   parse arg Xstring;   numeric digits 12;      say;     say
+        checksum= bitxor(CRC_32(Xstring), 'ffFFffFF'x) /*invoke CRC_32 to create a CRC. */
+        say center(' input string [length of' length(Xstring) "bytes] ", 79, '═')
+        say Xstring;      say                          /*show the string on its own line*/
+        say  "hex CRC─32 checksum ="   c2x(checksum)     left('', 15),
+             "dec CRC─32 checksum ="   c2d(checksum)   /*show the CRC─32 in hex and dec.*/
+        return

Task/CRC-32/Racket/crc-32.rkt

@@ -0,0 +1,15 @@
+#lang racket
+(define (bytes-crc32 data)
+  (bitwise-xor
+   (for/fold ([accum #xFFFFFFFF])
+     ([byte  (in-bytes data)])
+     (for/fold ([accum (bitwise-xor accum byte)])
+       ([num (in-range 0 8)])
+       (bitwise-xor (quotient accum 2)
+                    (* #xEDB88320 (bitwise-and accum 1)))))
+   #xFFFFFFFF))
+
+(define (crc32 s)
+  (bytes-crc32 (string->bytes/utf-8 s)))
+
+(format "~x" (crc32 "The quick brown fox jumps over the lazy dog"))

Task/CRC-32/Raku/crc-32-1.raku

@@ -0,0 +1,6 @@
+use NativeCall;
+
+sub crc32(int32 $crc, Buf $buf, int32 $len --> int32) is native('z') { * }
+
+my $buf = 'The quick brown fox jumps over the lazy dog'.encode;
+say crc32(0, $buf, $buf.bytes).fmt('%08x');

Task/CRC-32/Raku/crc-32-2.raku

@@ -0,0 +1,20 @@
+sub crc(
+    Blob $buf,
+             # polynomial including leading term, default: ISO 3309/PNG/gzip
+    :@poly = (1,0,0,0,0,0,1,0,0,1,1,0,0,0,0,0,1,0,0,0,1,1,1,0,1,1,0,1,1,0,1,1,1),
+    :$n = @poly.end,      # degree of polynomial
+    :@init = 1 xx $n,     # initial XOR bits
+    :@fini = 1 xx $n,     # final XOR bits
+    :@bitorder = 0..7,    # default: eat bytes LSB-first
+    :@crcorder = 0..$n-1, # default: MSB of checksum is coefficient of x⁰
+) {
+    my @bit = flat ($buf.list X+& (1 X+< @bitorder))».so».Int, 0 xx $n;
+
+    @bit[0   .. $n-1] «+^=» @init;
+    @bit[$_  ..$_+$n] «+^=» @poly if @bit[$_] for 0..@bit.end-$n;
+    @bit[*-$n..  *-1] «+^=» @fini;
+
+    :2[@bit[@bit.end X- @crcorder]];
+}
+
+say crc('The quick brown fox jumps over the lazy dog'.encode('ascii')).base(16);

Task/CRC-32/Ruby/crc-32-1.rb

@@ -0,0 +1,3 @@
+require 'zlib'
+printf "0x%08x\n", Zlib.crc32('The quick brown fox jumps over the lazy dog')
+# => 0x414fa339

Task/CRC-32/Ruby/crc-32-2.rb

@@ -0,0 +1,75 @@
+module CRC
+  # Divisor is a polynomial of degree 32 with coefficients modulo 2.
+  # We store Divisor in a 33-bit Integer; the polynomial is
+  #   Divisor[32] + Divisor[31] * x + ... + Divisor[0] * x**32
+  Divisor = [0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26, 32] \
+    .inject(0) {|sum, exponent| sum + (1 << (32 - exponent))}
+
+  # This table gives the crc (without conditioning) of every possible
+  # _octet_ from 0 to 255. Each _octet_ is a polynomial of degree 7,
+  #   octet[7] + octet[6] * x + ... + octet[0] * x**7
+  # Then remainder = Table[octet] is the remainder from
+  # _octet_ times x**32 divided by Divisor,
+  #   remainder[31] + remainder[30] + ... + remainder[0] * x**31
+  Table = Array.new(256) do |octet|
+    # Find remainder from polynomial long division.
+    #    octet[ 7] * x**32 + ... +   octet[0] * x**39
+    #  Divisor[32] * x**0  + ... + Divisor[0] * x**32
+    remainder = octet
+    (0..7).each do |i|
+      # Find next term of quotient. To simplify the code,
+      # we assume that Divisor[0] is 1, and we only check
+      # remainder[i]. We save remainder, forget quotient.
+      if remainder[i].zero?
+        # Next term of quotient is 0 * x**(7 - i).
+        # No change to remainder.
+      else
+        # Next term of quotient is 1 * x**(7 - i). Multiply
+        # this term by Divisor, then subtract from remainder.
+        #  * Multiplication uses left shift :<< to align
+        #    the x**(39 - i) terms.
+        #  * Subtraction uses bitwise exclusive-or :^.
+        remainder ^= (Divisor << i)
+      end
+    end
+    remainder >> 8      # Remove x**32 to x**39 terms.
+  end
+
+  module_function
+
+  def crc32(string, crc = 0)
+    # Pre-conditioning: Flip all 32 bits. Without this step, a string
+    # preprended with extra "\0" would have same crc32 value.
+    crc ^= 0xffff_ffff
+
+    # Iterate octets to perform polynomial long division.
+    string.each_byte do |octet|
+
+      # Update _crc_ by continuing its polynomial long division.
+      # Our current remainder is old _crc_ times x**8, plus
+      # new _octet_ times x**32, which is
+      #   crc[32] * x**8 + crc[31] * x**9 + ... + crc[8] * x**31 \
+      #     + (crc[7] + octet[7]) * x**32 + ... \
+      #     + (crc[0] + octet[0]) * x**39
+      #
+      # Our new _crc_ is the remainder from this polynomial divided by
+      # Divisor. We split the terms into part 1 for x**8 to x**31, and
+      # part 2 for x**32 to x**39, and divide each part separately.
+      # Then remainder 1 is trivial, and remainder 2 is in our Table.
+
+      remainder_1 = crc >> 8
+      remainder_2 = Table[(crc & 0xff) ^ octet]
+
+      # Our new _crc_ is sum of both remainders. (This sum never
+      # overflows to x**32, so is not too big for Divisor.)
+      crc = remainder_1 ^ remainder_2
+    end
+
+    # Post-conditioning: Flip all 32 bits. If we later update _crc_,
+    # this step cancels the next pre-conditioning.
+    crc ^ 0xffff_ffff
+  end
+end
+
+printf "0x%08x\n", CRC.crc32("The quick brown fox jumps over the lazy dog")
+# => 0x414fa339

Task/CRC-32/Rust/crc-32.rust

@@ -0,0 +1,26 @@
+fn crc32_compute_table() -> [u32; 256] {
+    let mut crc32_table = [0; 256];
+
+    for n in 0..256 {
+        crc32_table[n as usize] = (0..8).fold(n as u32, |acc, _| {
+            match acc & 1 {
+                1 => 0xedb88320 ^ (acc >> 1),
+                _ => acc >> 1,
+            }
+        });
+    }
+
+    crc32_table
+}
+
+fn crc32(buf: &str) -> u32 {
+    let crc_table = crc32_compute_table();
+
+    !buf.bytes().fold(!0, |acc, octet| {
+        (acc >> 8) ^ crc_table[((acc & 0xff) ^ octet as u32) as usize]
+    })
+}
+
+fn main() {
+    println!("{:x}", crc32("The quick brown fox jumps over the lazy dog"));
+}

Task/CRC-32/Scala/crc-32.scala

@@ -0,0 +1,4 @@
+import java.util.zip.CRC32
+val crc=new CRC32
+crc.update("The quick brown fox jumps over the lazy dog".getBytes)
+println(crc.getValue.toHexString)  //> 414fa339

Task/CRC-32/Seed7/crc-32.seed7

@@ -0,0 +1,7 @@
+$ include "seed7_05.s7i";
+  include "crc32.s7i";
+
+const proc: main is func
+  begin
+    writeln(ord(crc32("The quick brown fox jumps over the lazy dog")) radix 16 lpad0 8);
+  end func;

Task/CRC-32/Smalltalk/crc-32.st

@@ -0,0 +1 @@
+CRC32Stream hashValueOf:'The quick brown fox jumps over the lazy dog'

Task/CRC-32/Swift/crc-32.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+let strData = "The quick brown fox jumps over the lazy dog".dataUsingEncoding(NSUTF8StringEncoding,
+    allowLossyConversion: false)
+let crc = crc32(uLong(0), UnsafePointer<Bytef>(strData!.bytes), uInt(strData!.length))
+
+println(NSString(format:"%2X", crc))

Task/CRC-32/TXR/crc-32-1.txr

@@ -0,0 +1 @@
+(crc32 "The quick brown fox jumps over the lazy dog")

Task/CRC-32/TXR/crc-32-2.txr

@@ -0,0 +1,2 @@
+(with-dyn-lib "libz.so.1"
+  (deffi zlib-crc32 "crc32" ulong (ulong str uint)))

Task/CRC-32/TXR/crc-32-3.txr

@@ -0,0 +1,52 @@
+(defvarl crc-tab
+  #(#x00000000 #x77073096 #xee0e612c #x990951ba #x076dc419 #x706af48f
+    #xe963a535 #x9e6495a3 #x0edb8832 #x79dcb8a4 #xe0d5e91e #x97d2d988
+    #x09b64c2b #x7eb17cbd #xe7b82d07 #x90bf1d91 #x1db71064 #x6ab020f2
+    #xf3b97148 #x84be41de #x1adad47d #x6ddde4eb #xf4d4b551 #x83d385c7
+    #x136c9856 #x646ba8c0 #xfd62f97a #x8a65c9ec #x14015c4f #x63066cd9
+    #xfa0f3d63 #x8d080df5 #x3b6e20c8 #x4c69105e #xd56041e4 #xa2677172
+    #x3c03e4d1 #x4b04d447 #xd20d85fd #xa50ab56b #x35b5a8fa #x42b2986c
+    #xdbbbc9d6 #xacbcf940 #x32d86ce3 #x45df5c75 #xdcd60dcf #xabd13d59
+    #x26d930ac #x51de003a #xc8d75180 #xbfd06116 #x21b4f4b5 #x56b3c423
+    #xcfba9599 #xb8bda50f #x2802b89e #x5f058808 #xc60cd9b2 #xb10be924
+    #x2f6f7c87 #x58684c11 #xc1611dab #xb6662d3d #x76dc4190 #x01db7106
+    #x98d220bc #xefd5102a #x71b18589 #x06b6b51f #x9fbfe4a5 #xe8b8d433
+    #x7807c9a2 #x0f00f934 #x9609a88e #xe10e9818 #x7f6a0dbb #x086d3d2d
+    #x91646c97 #xe6635c01 #x6b6b51f4 #x1c6c6162 #x856530d8 #xf262004e
+    #x6c0695ed #x1b01a57b #x8208f4c1 #xf50fc457 #x65b0d9c6 #x12b7e950
+    #x8bbeb8ea #xfcb9887c #x62dd1ddf #x15da2d49 #x8cd37cf3 #xfbd44c65
+    #x4db26158 #x3ab551ce #xa3bc0074 #xd4bb30e2 #x4adfa541 #x3dd895d7
+    #xa4d1c46d #xd3d6f4fb #x4369e96a #x346ed9fc #xad678846 #xda60b8d0
+    #x44042d73 #x33031de5 #xaa0a4c5f #xdd0d7cc9 #x5005713c #x270241aa
+    #xbe0b1010 #xc90c2086 #x5768b525 #x206f85b3 #xb966d409 #xce61e49f
+    #x5edef90e #x29d9c998 #xb0d09822 #xc7d7a8b4 #x59b33d17 #x2eb40d81
+    #xb7bd5c3b #xc0ba6cad #xedb88320 #x9abfb3b6 #x03b6e20c #x74b1d29a
+    #xead54739 #x9dd277af #x04db2615 #x73dc1683 #xe3630b12 #x94643b84
+    #x0d6d6a3e #x7a6a5aa8 #xe40ecf0b #x9309ff9d #x0a00ae27 #x7d079eb1
+    #xf00f9344 #x8708a3d2 #x1e01f268 #x6906c2fe #xf762575d #x806567cb
+    #x196c3671 #x6e6b06e7 #xfed41b76 #x89d32be0 #x10da7a5a #x67dd4acc
+    #xf9b9df6f #x8ebeeff9 #x17b7be43 #x60b08ed5 #xd6d6a3e8 #xa1d1937e
+    #x38d8c2c4 #x4fdff252 #xd1bb67f1 #xa6bc5767 #x3fb506dd #x48b2364b
+    #xd80d2bda #xaf0a1b4c #x36034af6 #x41047a60 #xdf60efc3 #xa867df55
+    #x316e8eef #x4669be79 #xcb61b38c #xbc66831a #x256fd2a0 #x5268e236
+    #xcc0c7795 #xbb0b4703 #x220216b9 #x5505262f #xc5ba3bbe #xb2bd0b28
+    #x2bb45a92 #x5cb36a04 #xc2d7ffa7 #xb5d0cf31 #x2cd99e8b #x5bdeae1d
+    #x9b64c2b0 #xec63f226 #x756aa39c #x026d930a #x9c0906a9 #xeb0e363f
+    #x72076785 #x05005713 #x95bf4a82 #xe2b87a14 #x7bb12bae #x0cb61b38
+    #x92d28e9b #xe5d5be0d #x7cdcefb7 #x0bdbdf21 #x86d3d2d4 #xf1d4e242
+    #x68ddb3f8 #x1fda836e #x81be16cd #xf6b9265b #x6fb077e1 #x18b74777
+    #x88085ae6 #xff0f6a70 #x66063bca #x11010b5c #x8f659eff #xf862ae69
+    #x616bffd3 #x166ccf45 #xa00ae278 #xd70dd2ee #x4e048354 #x3903b3c2
+    #xa7672661 #xd06016f7 #x4969474d #x3e6e77db #xaed16a4a #xd9d65adc
+    #x40df0b66 #x37d83bf0 #xa9bcae53 #xdebb9ec5 #x47b2cf7f #x30b5ffe9
+    #xbdbdf21c #xcabac28a #x53b39330 #x24b4a3a6 #xbad03605 #xcdd70693
+    #x54de5729 #x23d967bf #xb3667a2e #xc4614ab8 #x5d681b02 #x2a6f2b94
+    #xb40bbe37 #xc30c8ea1 #x5a05df1b #x2d02ef8d))
+
+(defun crc32 (buf)
+  (let ((crc #xffffffff)
+        (l (len buf)))
+    (each ((i 0..l))
+      (set crc (logxor [crc-tab (logand (logxor crc [buf i]) #xff)]
+                       (ash crc -8))))
+    (logxor crc #xffffffff)))