• How To Implement Dictionary In Java

README.md Dictionary Attack This repository contains a simple example of a dictionary attack coded in Java. Description of Repository Content Here are the files you can find in this repository:. password.txt contains a list of passwords that we recover using the attack. DictionaryAttack.java is the source code for the attack. english.0 is the dictionary used during the attack to recover passwords Description of the password.txt file format The list of passwords that we recover using the attack is a text file in which each line contains a user account name followed by a password. There are two possible line formats: the first one contains an unsalted password while the second contains a salted password along with the salt.

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Username 0 unsaltedpassword username 1 salt saltedpassword The passwords are hashed using SHA-1 (see attack source code for implementation in the Java Cryptography Extension). When a salt is used, it is simply concatenated together with the passwords as follows: salt password. Description of the attack The attack simply reads the dictionary line by line and computes 6 different possible hashed passwords for the word contained in each line. These 6 possible hashes are compared to each of the passwords contained in the password.txt file for a match. If there is a match, we recovered a password. If not, we simply keep reading the dictionary line by line.

Concept of Hashing Introduction. You are implement a simple spell checker using a hash table. The program should read the dictionary and insert the words. C Program To Implement Dictionary Using Hashing Algorithm. Many encryption and compression functions return strings for which the result might contain arbitrary.

The 6 possible hashes computed for each word from the dictionary are:. SHA1(word). SHA1(drow) (reversed word). SHA1(wrd) (word without vowels). SHA1(salt word) (salted word). SHA1(salt drow) (salted reversed word). SHA1(salt wrd) (salted word without vowels) Note that the salts used in salted hashes are the ones includes in the password.txt file.

How to run the attack To run the attack, simply compile and run the DictionaryAttack.java file. All paths are hardcoded in the file so you will need to update them before you compile the source code. The output should be the following: Let's get things started. Joe's password is 'December' alice's password is 'tfosorciM' mary's password is 'Monday' john's password is 'brosba' bob's password is 'yllacitebahpla' guy's password is 'ntrstwrthnss' nick's password is 'uplifting' adam's password is 'vsblts' eve's password is 'wrrsm' andrew's password is 'kcitsdray' The program terminated. Note on complexity Note that this attack is a simple example and could be made far more efficient using various strategies.

One of them would be to precompute the possible hashes before checking the password list for matches. Since our password list and dictionary are fairly small in this example, I did not implement this feature.

A hash function that maps names to integers from 0 to 15. There is a collision between keys 'John Smith' and 'Sandra Dee'. A hash function is any that can be used to map of arbitrary size to data of fixed size. The values returned by a hash function are called hash values, hash codes, digests, or simply hashes. One use is a data structure called a, widely used in computer software for rapid data lookup. Hash functions accelerate table or database lookup by detecting duplicated records in a large file. An example is finding similar stretches in DNA sequences.

They are also useful in. A allows one to easily verify that some input data maps to a given hash value, but if the input data is unknown, it is deliberately difficult to reconstruct it (or equivalent alternatives) by knowing the stored hash value. This is used for assuring of transmitted data, and is the building block for, which provide. Hash functions are related to (and often confused with), error-correcting codes, and ciphers. Although these concepts overlap to some extent, each has its own uses and requirements and is designed and optimized differently. The Hash Keeper database maintained by the American National Drug Intelligence Center, for instance, is more aptly described as a catalogue of file fingerprints than of hash values. Contents.

Uses Hash tables Hash functions are used in, to quickly locate a data record (e.g., a definition) given its (the ). Section 6.6 of The C Programming Language presents a simple dictionary (hashtable) data structure. Create a simple hash function and some linked lists of structures, depending on the hash, assign which linked list to insert the value in. I think use lookup table and hashing key for this. One Response to “C program to implement Hash Table.

Write a C program to implement all the functions of a dictionary (ADT) using hashing. C program for dictionary using hashing,dictionary program in c language,c program to implement functions of. Blog for C, C, JAVA. It is a technique in which. Specifically, the hash function is used to map the search key to a list; the index gives the place in the hash table where the corresponding record should be stored.

Hash tables, also, are used to implement and. Typically, the domain of a hash function (the set of possible keys) is larger than its range (the number of different table indices), and so it will map several different keys to the same index. So then, each slot of a hash table is associated with (implicitly or explicitly) a of records, rather than a single record. For this reason, each slot of a hash table is often called a bucket, and hash values are also called bucket listing or a bucket index. Thus, the hash function only hints at the record's location.

Still, in a half-full table, a good hash function will typically narrow the search down to only one or two entries. People who write complete hash table implementations choose a specific hash function—such as a or —and independently choose a hash-table collision resolution scheme—such as. Caches Hash functions are also used to build for large data sets stored in slow media. A cache is generally simpler than a hashed search table, since any collision can be resolved by discarding or writing back the older of the two colliding items. This is also used in file comparison. Bloom filters.

Main article: When storing records in a large unsorted file, one may use a hash function to map each record to an index into a table T, and to collect in each bucket T i a of the numbers of all records with the same hash value i. Once the table is complete, any two duplicate records will end up in the same bucket. The duplicates can then be found by scanning every bucket T i which contains two or more members, fetching those records, and comparing them. With a table of appropriate size, this method is likely to be much faster than any alternative approach (such as sorting the file and comparing all consecutive pairs).

Protecting data. Main article: A hash value can be used to uniquely identify secret information. This requires that the hash function is, which means that it is very hard to find data that will generate the same hash value. These functions are categorized into cryptographic hash functions and provably secure hash functions. Functions in the second category are the most secure but also too slow for most practical purposes. Collision resistance is accomplished in part by generating very large hash values.

For example, one of the most widely used cryptographic hash functions, generates 160 bit values. Finding similar records. Main article: Hash functions can also be used to locate table records whose key is similar, but not identical, to a given key; or pairs of records in a large file which have similar keys. For that purpose, one needs a hash function that maps similar keys to hash values that differ by at most m, where m is a small integer (say, 1 or 2).

How To Implement Dictionary In Java

If one builds a table T of all record numbers, using such a hash function, then similar records will end up in the same bucket, or in nearby buckets. Then one need only check the records in each bucket T i against those in buckets T i+ k where k ranges between − m and m. This class includes the so-called algorithms, that are used to locate similar-sounding entries in large collection of. For this application, the hash function must be as insensitive as possible to data capture or transmission errors, and to trivial changes such as timing and volume changes, compression, etc.

Finding similar substrings The same techniques can be used to find equal or similar stretches in a large collection of strings, such as a document repository or a. In this case, the input strings are broken into many small pieces, and a hash function is used to detect potentially equal pieces, as above. The is a relatively fast that works in time on average.

It is based on the use of hashing to compare strings. Geometric hashing This principle is widely used in, and many other disciplines, to solve many in the or in, such as finding in a set of points, similar shapes in a list of shapes, similar in an, and so on. In these applications, the set of all inputs is some sort of, and the hashing function can be interpreted as a of that space into a grid of cells. The table is often an array with two or more indices (called a, grid index, bucket grid, and similar names), and the hash function returns an index.

This special case of hashing is known as or the grid method. Geometric hashing is also used in (usually under the name ) to and. Standard uses of hashing in cryptography. This section needs additional citations for. Unsourced material may be challenged and removed. (October 2017) Good hash functions, in the original sense of the term, are usually required to satisfy certain properties listed below.

The exact requirements are dependent on the application. For example, a hash function well suited to indexing data will probably be a poor choice for a. Determinism A hash procedure must be —meaning that for a given input value it must always generate the same hash value. In other words, it must be a of the data to be hashed, in the mathematical sense of the term. This requirement excludes hash functions that depend on external variable parameters, such as or the time of day. It also excludes functions that depend on the memory address of the object being hashed in cases that the address may change during execution (as may happen on systems that use certain methods of ), although sometimes rehashing of the item is possible. The determinism is in the context of the reuse of the function.

For example, adds the feature that hash functions make use of a randomized seed that is generated once when the Python process starts in addition to the input to be hashed. The Python hash is still a valid hash function when used within a single run. But if the values are persisted (for example, written to disk) they can no longer be treated as valid hash values, since in the next run the random value might differ. Uniformity A good hash function should map the expected inputs as evenly as possible over its output range. That is, every hash value in the output range should be generated with roughly the same. The reason for this last requirement is that the cost of hashing-based methods goes up sharply as the number of collisions—pairs of inputs that are mapped to the same hash value—increases.

If some hash values are more likely to occur than others, a larger fraction of the lookup operations will have to search through a larger set of colliding table entries. Note that this criterion only requires the value to be uniformly distributed, not random in any sense. A good randomizing function is (barring computational efficiency concerns) generally a good choice as a hash function, but the converse need not be true. Hash tables often contain only a small subset of the valid inputs. For instance, a club membership list may contain only a hundred or so member names, out of the very large set of all possible names. In these cases, the uniformity criterion should hold for almost all typical subsets of entries that may be found in the table, not just for the global set of all possible entries. In other words, if a typical set of m records is hashed to n table slots, the probability of a bucket receiving many more than m/ n records should be vanishingly small.

In particular, if m is less than n, very few buckets should have more than one or two records. (In an ideal ', no bucket should have more than one record; but a small number of collisions is virtually inevitable, even if n is much larger than m – see the ). When testing a hash function, the uniformity of the distribution of hash values can be evaluated by the. Defined range It is often desirable that the output of a hash function have fixed size (but see below).

If, for example, the output is constrained to 32-bit integer values, the hash values can be used to index into an array. Such hashing is commonly used to accelerate data searches. On the other hand, cryptographic hash functions produce much larger hash values, in order to ensure the computational complexity of brute-force inversion. For example, one of the most widely used cryptographic hash functions, produces a 160-bit value.

Producing fixed-length output from variable length input can be accomplished by breaking the input data into chunks of specific size. Hash functions used for data searches use some arithmetic expression which iteratively processes chunks of the input (such as the characters in a string) to produce the hash value. In cryptographic hash functions, these chunks are processed by a, with the last chunk being padded if necessary.

In this case, their size, which is called block size, is much bigger than the size of the hash value. For example, in, the hash value is 160 bits and the block size 512 bits. Variable range In many applications, the range of hash values may be different for each run of the program, or may change along the same run (for instance, when a hash table needs to be expanded). In those situations, one needs a hash function which takes two parameters—the input data z, and the number n of allowed hash values.

A common solution is to compute a fixed hash function with a very large range (say, 0 to 2 32 − 1), divide the result by n, and use the division's. If n is itself a power of 2, this can be done by and. When this approach is used, the hash function must be chosen so that the result has fairly uniform distribution between 0 and n − 1, for any value of n that may occur in the application.

Depending on the function, the remainder may be uniform only for certain values of n, e.g. We can allow the table size n to not be a power of 2 and still not have to perform any remainder or division operation, as these computations are sometimes costly. For example, let n be significantly less than 2 b. Consider a (PRNG) function P(key) that is uniform on the interval 0, 2 b − 1. A hash function uniform on the interval 0, n-1 is n P(key)/2 b. We can replace the division by a (possibly faster) right: nP(key) b.

Variable range with minimal movement (dynamic hash function) When the hash function is used to store values in a hash table that outlives the run of the program, and the hash table needs to be expanded or shrunk, the hash table is referred to as a dynamic hash table. A hash function that will relocate the minimum number of records when the table is – where z is the key being hashed and n is the number of allowed hash values – such that H( z, n + 1) = H( z, n) with probability close to n/( n + 1). And spiral storage are examples of dynamic hash functions that execute in constant time but relax the property of uniformity to achieve the minimal movement property. Uses a dynamic hash function that requires space proportional to n to compute the hash function, and it becomes a function of the previous keys that have been inserted. Several algorithms that preserve the uniformity property but require time proportional to n to compute the value of H( z, n) have been invented. A hash function with minimal movement is especially useful in. Data normalization In some applications, the input data may contain features that are irrelevant for comparison purposes.

For example, when looking up a personal name, it may be desirable to ignore the distinction between upper and lower case letters. For such data, one must use a hash function that is compatible with the data criterion being used: that is, any two inputs that are considered equivalent must yield the same hash value. This can be accomplished by normalizing the input before hashing it, as by upper-casing all letters. Continuity 'A hash function that is used to search for similar (as opposed to equivalent) data must be as as possible; two inputs that differ by a little should be mapped to equal or nearly equal hash values.' Note that continuity is usually considered a fatal flaw for checksums, and other related concepts. Continuity is desirable for hash functions only in some applications, such as hash tables used in. Non-invertible In cryptographic applications, hash functions are typically expected to be practically, meaning that it is not realistic to reconstruct the input datum x from its hash value h( x) alone without spending great amounts of computing time (see also ).

Hash function algorithms For most types of hashing functions, the choice of the function depends strongly on the nature of the input data, and their in the intended application. Trivial hash function If the data to be hashed is small enough, one can use the data itself (reinterpreted as an integer) as the hashed value. The cost of computing this 'trivial' hash function is effectively zero. This hash function is, as it maps each input to a distinct hash value. The meaning of 'small enough' depends on the size of the type that is used as the hashed value.

For example, in, the hash code is a 32-bit integer. Thus the 32-bit integer Integer and 32-bit floating-point Float objects can simply use the value directly; whereas the 64-bit integer Long and 64-bit floating-point Double cannot use this method. Other types of data can also use this perfect hashing scheme. For example, when mapping between, one can use the binary encoding of each character, interpreted as an integer, to index a table that gives the alternative form of that character ('A' for 'a', '8' for '8', etc.). If each character is stored in 8 bits (as in extended or ), the table has only 2 8 = 256 entries; in the case of characters, the table would have 17×2 16 = 200000000♠1 114 112 entries.

The same technique can be used to map like 'us' or 'za' to country names (26 2 = 676 table entries), 5-digit zip codes like 13083 to city names ( 000000000♠100 000 entries), etc. Invalid data values (such as the country code 'xx' or the zip code 00000) may be left undefined in the table or mapped to some appropriate 'null' value.

Perfect hashing. A minimal perfect hash function for the four names shown A perfect hash function for n keys is said to be minimal if its range consists of n consecutive integers, usually from 0 to n−1. Besides providing single-step lookup, a minimal perfect hash function also yields a compact hash table, without any vacant slots. Minimal perfect hash functions are much harder to find than perfect ones with a wider range.

Hashing uniformly distributed data If the inputs are bounded-length and each input may occur with probability (such as, numbers, etc.), then a hash function needs to map roughly the same number of inputs to each hash value. For instance, suppose that each input is an integer z in the range 0 to N−1, and the output must be an integer h in the range 0 to n−1, where N is much larger than n. Then the hash function could be h = z mod n (the remainder of z divided by n), or h = ( z × n) ÷ N (the value z scaled down by n/ N and truncated to an integer), or many other formulas. Hashing data with other distributions These simple formulas will not do if the input values are not equally likely, or are not independent.

For instance, most patrons of a will live in the same geographic area, so their telephone numbers are likely to begin with the same 3 to 4 digits. In that case, if m is 10000 or so, the division formula ( z × m) ÷ M, which depends mainly on the leading digits, will generate a lot of collisions; whereas the remainder formula z mod m, which is quite sensitive to the trailing digits, may still yield a fairly even distribution. Hashing variable-length data When the data values are long (or variable-length) —such as personal names, or mail messages—their distribution is usually very uneven, with complicated dependencies. For example, text in any has highly non-uniform distributions of, and, very characteristic of the language. For such data, it is prudent to use a hash function that depends on all characters of the string—and depends on each character in a different way. In cryptographic hash functions, a is usually used.

In general, the scheme for hashing such data is to break the input into a sequence of small units (, etc.) and combine all the units b1, b2, b m sequentially, as follows S ← S0; // Initialize the state. For k in 1, 2., m do // Scan the input data units: S ← F(S, bk); // Combine data unit k into the state. Return G(S, n) // Extract the hash value from the state. This schema is also used in many text checksum and fingerprint algorithms. The state variable S may be a 32- or 64-bit unsigned integer; in that case, S0 can be 0, and G( S, n) can be just S mod n. The best choice of F is a complex issue and depends on the nature of the data. If the units b k are single bits, then F( S, b) could be, for instance if highbit(S) = 0 then return 2.

S + b else return (2. S + b) ^ P Here highbit( S) denotes the most significant bit of S; the '.' operator denotes unsigned integer multiplication with lost; ' ^' is the bitwise operation applied to words; and P is a suitable fixed word. Special-purpose hash functions In many cases, one can design a special-purpose hash function that yields many fewer collisions than a good general-purpose hash function. For example, suppose that the input data are file names such as FILE0000.CHK, FILE0001.CHK, FILE0002.CHK, etc., with mostly sequential numbers.

For such data, a function that extracts the numeric part k of the file name and returns k mod n would be nearly optimal. Needless to say, a function that is exceptionally good for a specific kind of data may have dismal performance on data with different distribution. Rolling hash. Main article: In some applications, such as, one must compute a hash function h for every k-character of a given n-character string t; where k is a fixed integer, and n is greater than k. The straightforward solution, which is to extract every such substring s of t and compute h( s) separately, requires a number of operations proportional to k n. However, with the proper choice of h, one can use the technique of rolling hash to compute all those hashes with an effort proportional to k + n. Universal hashing A scheme is a that selects a hashing function h among a family of such functions, in such a way that the probability of a collision of any two distinct keys is 1/ n, where n is the number of distinct hash values desired—independently of the two keys.

Universal hashing ensures (in a probabilistic sense) that the hash function application will behave as well as if it were using a random function, for any distribution of the input data. It will, however, have more collisions than perfect hashing and may require more operations than a special-purpose hash function. See also unique permutation hashing.

Hashing with checksum functions One can adapt certain checksum or fingerprinting algorithms for use as hash functions. Some of those algorithms will map arbitrarily long string data z, with any typical real-world distribution—no matter how non-uniform and dependent—to a 32-bit or 64-bit string, from which one can extract a hash value in 0 through n − 1. This method may produce a sufficiently uniform distribution of hash values, as long as the hash range size n is small compared to the range of the checksum or fingerprint function. However, some checksums fare poorly in the, which may be a concern in some applications. In particular, the popular CRC32 checksum provides only 16 bits (the higher half of the result) that are usable for hashing. – Moreover, each bit of the input has a deterministic effect on each bit of the CRC32 output; that is, one can tell without looking at the rest of the input which bits of the output will flip if the input bit is flipped, so care must be taken to use all 32 bits when computing the hash from the checksum.

– Multiplicative hashing Multiplicative hashing is a simple type of hash function often used by teachers introducing students to hash tables. Multiplicative hash functions are simple and fast, but have higher collision rates in hash tables than more sophisticated hash functions. In many applications, such as hash tables, collisions make the system a little slower but are otherwise harmless. In such systems, it is often better to use hash functions based on multiplication—such as and the SBoxHash—or even simpler hash functions such as —and tolerate more collisions; rather than use a more complex hash function that avoids many of those collisions but takes longer to compute. Multiplicative hashing is susceptible to a 'common mistake' that leads to poor diffusion—higher-value input bits do not affect lower-value output bits. Hashing with cryptographic hash functions Some, such as, have even stronger uniformity guarantees than checksums or fingerprints, and thus can provide very good general-purpose hashing functions.

In ordinary applications, this advantage may be too small to offset their much higher cost. However, this method can provide uniformly distributed hashes even when the keys are chosen by a malicious agent.

This feature may help to protect services against. Hashing by nonlinear table lookup. This section does not any. Unsourced material may be challenged and. (September 2015) Tables of random numbers (such as 256 random 32-bit integers) can provide high-quality nonlinear functions to be used as hash functions or for other purposes such as cryptography.

The key to be hashed is split into 8-bit (one-byte) parts, and each part is used as an index for the nonlinear table. The table values are then added by arithmetic or XOR addition to the hash output value. Because the table is just 1024 bytes in size, it fits into the cache of modern microprocessors and allows very fast execution of the hashing algorithm. As the table value is on average much longer than 8 bits, one bit of input affects nearly all output bits. This algorithm has proven to be very fast and of high quality for hashing purposes (especially hashing of integer-number keys). Efficient hashing of strings. See also: Modern microprocessors will allow for much faster processing, if 8-bit character strings are not hashed by processing one character at a time, but by interpreting the string as an array of 32 bit or 64 bit integers and hashing/accumulating these 'wide word' integer values by means of arithmetic operations (e.g.

Multiplication by constant and bit-shifting). The remaining characters of the string which are smaller than the word length of the CPU must be handled differently (e.g. Being processed one character at a time). This approach has proven to speed up hash code generation by a factor of five or more on modern microprocessors of a word size of 64 bit. Another approach is to convert strings to a 32 or 64 bit numeric value and then apply a hash function. One method that avoids the problem of strings having great similarity ('Aaaaaaaaaa' and 'Aaaaaaaaab') is to use a (CRC) of the string to compute a 32- or 64-bit value.

While it is possible that two different strings will have the same CRC, the likelihood is very small and only requires that one check the actual string found to determine whether one has an exact match. CRCs will be different for strings such as 'Aaaaaaaaaa' and 'Aaaaaaaaab'. Although CRC codes can be used as hash values, they are not cryptographically secure, because they are not. Locality-sensitive hashing (LSH) is a method of performing probabilistic dimension reduction of high-dimensional data. The basic idea is to hash the input items so that similar items are mapped to the same buckets with high probability (the number of buckets being much smaller than the universe of possible input items).

This is different from the conventional hash functions, such as those used in cryptography, as in this case the goal is to minimize the probability of 'collision' of every item. One example of LSH is algorithm used for finding similar documents (such as web-pages): Let h be a hash function that maps the members of A and B to distinct integers, and for any set S define h min( S) to be the member x of S with the minimum value of h( x). Then h min( A) = h min( B) exactly when the minimum hash value of the union A ∪ B lies in the intersection A ∩ B. Human Values And Professional Ethics By Rr Gaur Pdf File.

Therefore, Pr h min( A) = h min( B) = J( A, B). In other words, if r is a random variable that is one when h min( A) = h min( B) and zero otherwise, then r is an of J( A, B), although it has too high a to be useful on its own. The idea of the MinHash scheme is to reduce the variance by averaging together several variables constructed in the same way. Origins of the term The term 'hash' offers a natural analogy with its non-technical meaning (to 'chop' or 'make a mess' out of something), given how hash functions scramble their input data to derive their output. In his research for the precise origin of the term, notes that, while of appears to have been the first to use the concept of a hash function in a memo dated January 1953, the term itself would only appear in published literature in the late 1960s, on Herbert Hellerman's Digital Computer System Principles, even though it was already widespread jargon by then.

List of hash functions. Konheim, Alan (2010).

Hashing in Computer Science: Fifty Years of Slicing and Dicing. ^ Menezes, Alfred J.; van Oorschot, Paul C.; Vanstone, Scott A (1996). Handbook of Applied Cryptography. Retrieved 2017-03-24.

^ Sedgewick, Robert (2002). Algorithms in Java (3 ed.).

Addison Wesley. Retrieved May 19, 2014. Plain ASCII is a 7-bit character encoding, although it is often stored in 8-bit bytes with the highest-order bit always clear (zero).

Therefore, for plain ASCII, the bytes have only 2 7 = 128 valid values, and the character translation table has only this many entries. 'Some applications of Rabin's fingerprinting method'. Sequences II: Methods in Communications, Security, and Computer Science.

Shlomi Dolev, Limor Lahiani, Yinnon Haviv, 'Unique permutation hashing', Theoretical Computer Science Volume 475, 4 March 2013, Pages 59–65. Bret Mulvey, in. Accessed April 10, 2009. 'The Art of Computer Programming'. Volume 3: 'Sorting and Searching'. Section '6.4. ^ Peter Kankowski.

Section 'Multiplicative hashing'. Bret Mulvey, in. Accessed April 10, 2009. Performance in Practice of String Hashing Functions. Peter Kankowski. Cam-Winget, Nancy; Housley, Russ; Wagner, David; Walker, Jesse (May 2003). Communications of the ACM.

46 (5): 35–39. Rajaraman and J. Ullman (2010).

Knuth, Donald E. Sorting and searching (2. Printing, newly updated and rev. Boston u.a.: Addison-Wesley. Knuth, Donald E.

Sorting and searching (2. Printing, newly updated and rev. Boston u.a.: Addison-Wesley.

September 22, 2003. Retrieved November 1, 2012. The djb2 algorithm (k=33) was first reported by dan bernstein many years ago in comp.lang.c.

All third party products, brands or trademarks listed above are the sole property of their respective owner. |||| © 1996-2016 Driver Support. No affiliation or endorsement is intended or implied. Clevo lp200t drivers. All rights reserved. DRIVER SUPPORT, the DRIVER SUPPORT logo, and DRIVERSUPPORT.COM are trademarks of Driver Support and its affiliated companies.

External links Look up in Wiktionary, the free dictionary. by Timo Denk. by Bob Jenkins. by Mayur Patel. Latest Trends on Computers, Vol.2, pp. 483–489, CSCC conference, Corfu, 2010.