#include<stdio.h>
#include<iostream>
#include <fstream>
#include <stdlib.h>
#include<cstdlib>
#include<conio.h>
#include<string>




#include<string.h>

#include <sys/stat.h>


#define BASE 65521 /* largest prime smaller than 65536 */

      /*
         Update a running Adler-32 checksum with the bytes buf[0..len-1]
       and return the updated checksum. The Adler-32 checksum should be
       initialized to 1.

       Usage example:

         unsigned long adler = 1L;

         while (read_buffer(buffer, length) != EOF) {
           adler = update_adler32(adler, buffer, length);
         }
         if (adler != original_adler) error();
      */
      unsigned long update_adler32(unsigned long adler,
         unsigned char *buf, int len)
      {
        unsigned long s1 = adler & 0xffff;
        unsigned long s2 = (adler >> 16) & 0xffff;
        int n;

        for (n = 0; n < len; n++) {
          s1 = (s1 + buf[n]) % BASE;
          s2 = (s2 + s1)     % BASE;
        }
        return (s2 << 16) + s1;
      }
using namespace std;
	  void main()
	  {
	     unsigned long adler = 1L;
	     ofstream myfile;
             myfile.open ("example.txt");
             myfile << "this is an adler32 algorithm for computing hash code of a given file";
             myfile <<"\ncomputing using adler32 , using the HMAC (Hash Message Authentication Code) ";
		
		 myfile.close();

	    
	     

		
		 
		
		 
		 //Open file
		
	

		string STRING;
		ifstream infile;
		infile.open ("example.txt");
		string previousLine="";
		while(!infile.eof()) 
		{
			getline(infile,STRING); 
			if (STRING != previousLine)
			{
				previousLine=STRING;
				cout<<STRING<<endl; 
			        int strnglen =STRING.length();
				adler = update_adler32(adler, (unsigned char*)STRING.c_str(),strnglen);
			}

		}
		infile.close();

		  
			 
	  }

adler = update_adler32(adler, "\n", 1);

#define  _POSIX_C_SOURCE 200809L
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>

#define  ADLER32_BASE 65521

uint32_t adler32(uint32_t const sum, const int descriptor, off_t *const length)
{
    unsigned char buffer[32768]; /* Uses a lot of stack! */
    ssize_t       n;
    int           saved_errno;
    off_t         total = 0;
    unsigned int  sum1 = sum & 0xFFFFU;
    unsigned int  sum2 = (sum >> 16U) & 0xFFFFU;

    saved_errno = errno;

    while (1) {

        n = read(descriptor, buffer, sizeof buffer);
        if (n > (ssize_t)0) {
            const unsigned char       *head = buffer;
            const unsigned char *const tail = buffer + n;

            total += (off_t)n;

            while (head < tail) {
                sum1 = (sum1 + *(head++)) % ADLER32_BASE;
                sum2 = (sum2 + sum1)      % ADLER32_BASE;
            }

            continue;

        } else
        if (n == (ssize_t)-1 && errno == EINTR)
            continue;

        if (n == (ssize_t)-1)
            saved_errno = errno;
        else
        if (n != (ssize_t)0)
            saved_errno = EIO;

        if (length)
            *length = total;

        errno = saved_errno;

        return (uint32_t)sum1 + ((uint32_t)sum2 << 16U);
    }
}

int main(int argc, char *argv[])
{
    uint32_t sum;
    off_t    length;
    int      arg, fd, result;

    if (argc < 2) {
        fprintf(stderr, "\nUsage: %s FILE(s)...\n\n", argv[0]);
        return 0;
    }

    for (arg = 1; arg < argc; arg++) {

        do {
            fd = open(argv[arg], O_RDONLY | O_NOCTTY);
        } while (fd == -1 && errno == EINTR);
        if (fd == -1) {
            fprintf(stderr, "%s: %s.\n", argv[arg], strerror(errno));
            return 1;
        }

        errno = 0;
        sum = adler32(1, fd, &length);
        if (errno) {
            fprintf(stderr, "%s: %s.\n", argv[arg], strerror(errno));
            return 1;
        }

        printf("%s: 0x%08lx = %lu (%lu bytes)\n",
               argv[arg], (unsigned long)sum, (unsigned long)sum, (unsigned long)length);
        fflush(stdout);

        do {
            result = close(fd);
        } while (result == -1 && errno == EINTR);
        if (result == -1) {
            fprintf(stderr, "%s: Error closing file: %s.\n", argv[arg], strerror(errno));
            return 1;
        }
    }

    return 0;
}