Addendum to my Anti-College Rant

Posted in Uncategorized on July 2, 2011 by z4klon

I’ve been thinking about what I spoke on previously regarding college; thought I might make some clarifications to avoid coming across like some jackass saying college is totally worthless.

College indeed has worth; it is not worthwhile.  The net has made studying disparate subjects so easy that one can do so without walking anywhere, paying a cent in tuition (only fees to an ISP), buying no books, etc.

The only real payoff of going to college is that you are to a degree forced to learn. Many people would not choose to go to the library to engage in self-study projects were it not for the threat of the F-hammer dropping on them at semester’s end. Likely, if you are a lemming, college is the place to be.

Likewise if you have no creativity–one who can’t decide what they need to learn is probably going to be better off forking over cash to be spoonfed. This is actually what I did when I attended college; I didn’t have a clue where to get started, but once I did, I came to the realization that what I was doing was paying money to learn things in a less-efficient manner. People in the class who didn’t get it slowed the whole class down; I was told to study things I had no interest in (which, after graduation, I came to find were totally useless in terms of getting employed).

And to return full-circle to my main point, once you know exactly what it is you want to study, finding resources online typically isn’t that difficult of a task.

To give an anacdote for what I’ve said, I’m now in the process of (attempting) to learn of PLCs. Very little of what my tech degree entailed involved anything regarding PLCs, so as far as my degree program went in helping me, I was SOL. Had I the time and money back, and the foresight to see that I was to be working with PLCs in my future, I certainly would have saved my money from college to buy a PLC and perhaps some vendor-specific training courses on it. Or some books via Amazon.

Education, in the tech field, typically involves giving students a laundry list of rudimentary training for a variety of topics; it unleashes these ‘scholars’ on a workforce that has no need for generalists. The coursework is set in stone (to a large degree); one can’t just go to college in CE and demand to learn strictly hardware (and graduate).

Why colleges don’t cater directly to the needs of the market is beyond me. E.g. a college in a city with a large factory might have more courses in CNC operation & programming, PLC courses, teach SCADA, robotics, etc. A city without such enterprises might have more generalistic programs.

I should wrap it up here, because I really don’t want to talk any more about this issue, save for this clarification. I’m not against college; I’m against people thinking college is a panacea to a better future. That’s simply not guaranteed anymore, for several reasons. First, nearly everyone has a college degree; there’s no exclusivity factor to education. Some attempt to counter such by going to graduate school; in twenty years, we might see banks requiring a Master’s degree to be a teller (hyperbole).

So college doesn’t get you a job all the time. But what of college grads making bank (i.e. those that do nail down gainful employment). I’d argue that this is a mirage; college tends to attract people who are at least slightly more motivated (as a rule) than those that drop out of college, or fail to attend it altogether. Maybe most grads are paid more, but a close analysis needs to be made for the opportunity cost of attending college; one could have worked for four (or more) years and be 80k-100k in the black over someone who went in debt 20k to finance school.

That’s actually the case with myself compared to many of those I grew up with. Some of them are extensively in debt; some, with parental assistance, hardly at all. But few of those can say they’re 40k in the black some two years after dropping out of school.

Maybe I’m an anomaly; however, I’d feel guilty if I didn’t at least write a blog post (that maybe three people will read) about my feelings on this topic. If it helps one person to avoid being fleeced through the system, this will have been well worth the 15 some minutes it took me to write.

You Don’t Need College

Posted in Uncategorized on June 8, 2011 by z4klon

Preface: I have to say that in re-reading my own writing (henceforth), I come across as someone who hates college.  I don’t hate college; in fact, I credit a two-year technical degree with sparking my passion in IT.  It was only in hindsight that I came to the conclusion that my degree wasn’t what was valuable; rather, it was the passion itself. With that, you no longer need college.

I spent the better part of last week going back and forth on an idea I’ve been throwing around. Basically, it entailed applying the conjecture that post-secondary education is made irrelevant in many fields by the advent of free educational resources available on the net. Think computer science, think CE, IT, etc. One could probably generalize this to many other fields as well.

My idea was to create a website, something I drafted under the tentatively titled ‘DegreelessCS,’ that compiled an array of free resources that could compete effectively against a typical undergraduate program. While I still think it’s a good idea, I think it’s redundant. Basically, anyone searching for resources on how to get a degree in CS (or IT, CE, or others), is not going to need this site: they already ‘get it,’ they’ll already be out on Google combing for certain topics that interest them. The most I could hope for would be to be a middle-man, a giver of links.

So, to save myself the time and energy I would have spent making an unnecessary website, let me explain the framework I hoped to have the site embody: you get a framework for a typical collegiate undergraduate program (the ACM makes guides of just this sort).

Having a guideline, you search out for resources to fulfil what you’re looking to learn. Don’t like combinotorics? Don’t study it. Have a passing knowledge of database theory, don’t see it being very applicable? Pass it over. Don’t like Java? Code in C. Like web design? Study it exclusively.

Fast forward a couple of years after doing this, and you have a learned student who’s studied topics that interest himself, instead of one who studied shit he found irrelevant/tedious. Save 20K in debt for a piece of paper and rediscover the fun of learning in the process.

Compare this with a college program. “You’re going to learn x,y,z.” Don’t like database theory? Tough luck, you have to learn it or we fail. Have a grievance with Java? Tough, that’s the language we code in here. Like web design? Great, you can take both of the two classes we offer of it; it’s not required for graduation, and you won’t get closer to such in doing so.

On the learning environment: noone could conceivably claim that the best way to teach is found in college classrooms.  Sitting for an hour in a one-ended conversation on some subject matter, assigning readings (where the real learning takes place), exercises, tests.  You either get the material, or you don’t; you pass the tests or you fail, and oftentimes, little to nothing is done to help those who struggle with the material, to say nothing with those who disagree with the applicability of it.

The predictable result of these sorts of programs are students who, after graduation, almost immediately forget everything they were taught. Because students who don’t like what they learn won’t use it; what isn’t used is soon forgotten. They weren’t taught to follow their passions, these people are taught that with some effort and a knack for rote recitation of regurgitated facts, they are entitled to a job in tech.

We now have a situation with tech grads who can’t get jobs even with a degree; the market is flooded with applicants who went through the motions, filled their heads with four years of facts, have little to no initiative, don’t learn things independently, don’t stay up to date with current trends, have no appreciation for how applying technology can, can’t or could increase a company’s bottom line (the only reason why a single person works in tech, period), and then they wonder why they’re flipping burgers.

I can’t say this process works for everyone, but it certainly has worked for me. Surely, I can’t say that I know all subjects as well as many who’ve passed through CS programs; then again, I don’t need to, and likely, neither do they. What we have with the tech educational system at the present is courseloads that seek to expose students (oftentimes) to antiquated technology, things that people don’t need to know, don’t care to, or don’t like to learn.

I’ve gone through the educational system and found it lacking in both value and substance; were I to go back and recount all that which I had learned in doing so, I’d have to sum it up in saying the most important thing I’ve gained in five years and tens of thousands in tuition is a passion for doing fun things with technology, utilizing it to meet ends of my own choosing, and that with Google, I can learn practically anything.  And so can you; you don’t need college.

 

 

Roll your own File Signatures

Posted in Uncategorized on June 4, 2011 by z4klon

Putzing around on the computer today, I wondered about the file program and the breadth of things it tests for; how does it know what nearly everything is?

Also, how could I add to the program a signature of my own making?

To answer the first question, I had to learn some things about how the file program worked. Ugh, learning; IT does that to you, makes you learn shit every day. *Sigh* /sarcasm

The file program looks to two files (principally) to see what a given input file is: /usr/share/misc/magic.mgc and /etc/magic . On my system, the former was compiled and the second one was empty, save for the commented-out beginning:

# Magic local data for file(1) command.
# Insert here your local magic data. Format is described in magic(5).

Make a note of those two referenced man pages, because you should consult them for any specifics I fail to mention (there’s a lot to be said on this subject, so seriously, check those out).

As I said, the magic.mgc file is compiled, so I couldn’t verify just what I was looking at (directly).

I tried doing some things to it:

$ strings /usr/share/misc/magic.mgc | less
$ strings /usr/share/misc/magic.mgc | wc -l
$ strings /usr/share/misc/magic.mgc | egrep -i "JPG|JPEG"

So what I decided to do was to get cracking on checking out the source.


$ sudo apt-get source file
$ cd ./file-5.04/magic/Magdir/
$ ls
acorn           diamond        java         ocaml             spec
adi             diff           jpeg         octave            spectrum
adventure       digital        karma        ole2compounddocs  sql
allegro         dolby          kde          olf               sun
alliant         dump           kml          os2               sysex
alpha           dyadic         lecter       os400             teapot
amanda          editors        lex          os9               terminfo
amigaos         efi            lif          osf1              tex
animation       elf            linux        palm              tgif
apl             encore         lisp         parix             ti-8x
apple           epoc           llvm         pbm               timezone
applix          erlang         lua          pdf               troff
archive         esri           luks         pdp               tuxedo
asterix         fcs            mach         perl              typeset
att3b           filesystems    macintosh    pgp               unicode
audio           flash          magic        pkgadd            unknown
basis           fonts          mail.news    plan9             uuencode
bflt            fortran        maple        plus5             varied.out
blender         frame          mathcad      printer           varied.script
blit            freebsd        mathematica  project           vax
bout            fsav           matroska     psdbms            vicar
bsdi            games          mcrypt       pulsar            virtual
btsnoop         gcc            mercurial    pyramid           virtutech
c64             geos           mime         python            visx
cad             gimp           mips         revision          vms
cafebabe        gnome-keyring  mirage       riff              vmware
cddb            gnu            misctools    rpm               vorbis
chord           gnumeric       mkid         rtf               vxl
cisco           grace          mlssa        ruby              warc
citrus          graphviz       mmdf         sc                weak
c-lang          gringotts      modem        sccs              windows
clarion         hitachi-sh     motorola     scientific        wireless
claris          hp             mozilla      securitycerts     wordprocessors
clipper         human68k       msdos        sendmail          xdelta
commands        ibm370         msvc         sequent           xenix
communications  ibm6000        mup          sgi               xilinx
compress        iff            natinst      sgml              xo65
console         images         ncr          sharc             xwindows
convex          inform         netbsd       sinclair          zilog
cracklib        intel          netscape     sketch            zyxel
ctags           interleaf      netware      smalltalk
dact            island         news         sniffer
database        ispell         nitpicker    softquad

Cool.

Anyway, that brings me back to my second point, which is making your own file sigs for whatever you need them for. Could be you’re working with something file doesn’t recognize, could be you’re looking to hide something important, you create a rule by which you could retrieve specific files based on some agreed-upon rule with another party.

I added the following to my /etc/magic file:

vim /etc/magic
# Magic local data for file(1) command.
# Insert here your local magic data. Format is described in magic(5).
0       string  LOL     lulzfile

What you have is a signature starting at offset 0, it’s a string, the string is “LOL,” and it returns a message of it being a “lulzfile.”

Anything beyond this is covered in depth in the aforementioned documentation.

Installing Django

Posted in Uncategorized on June 2, 2011 by z4klon

Short post here, dealing with an install issue on django I thought i should clarify.

Got this error:

django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module: No module named MySQLdb

Solved via this:

sudo apt-get install python-mysqldb

This was neglected in the Django documentation, thought it’d be good to note it for future reference.

Might do a longer elaboration on Django at a later time.

Linux Forensics: Pattern Matching with Grep and Related Tools

Posted in Uncategorized on June 2, 2011 by z4klon

I’m trying to piece together a resume from the scattered work I’ve done over the years; thought I’d post this here, dug it out of my docs folder. patterns

Linux Forensics: Pattern Matching with Grep and Related Tools

Pattern matching is locating a given sequence within a pool of information. Everyone who has used Google knows in essence what this is and the importance of refining search terms to weed out unnecessary information from the vast sums available on the Internet. This analogy is applicable to forensic investigations involving digital evidence; it is desirable to avoid the clutter of unwanted information. The benefits of pattern matching are two in number: to increase productivity and the likelihood of finding desired information. A synopsis of regular expressions and an exploration of their importance and efficacy regarding those ends follows; their use is applied with tools common to most GNU/Linux systems. Ancillary topics include network forensic tools and scripting, the latter of which seeks to provide analogous functions between the tools discussed and competing forensic software.

Introducing Pattern Matching:

A term intertwined with pattern matching is ‘regular expressions’. They’re synonyms in essence, with the former denoting the action of locating a desired occurrence in a larger data set, and the latter denoting the language by which this is often accomplished.I II Another, potentially inaccurate, synonym for pattern matching and regular expressions is “grep.” The word “grep” goes back to Unix in which editors like ed which phrased search and print functions like g/re/p, wherein “re” is the desired search pattern, and it would print the result to standard output.III Forward closer to the present day, and grep is less used in such a specific context; it now means approximately to find a given pattern. Specifically, grep is one of many programs that use regular expressions (the language of pattern matching). Alternatively, it is oft used as a verb to connote this action. This paper will make liberal use of the word in the spirit of grep’s use in colloquial English.

Over time regular expressions became diversified into a multitude of different camps, of which about a dozen are reasonably popular at the present day. Some are as followsIV:
Perl
GNU BRE
GNU ERE
POSIX BRE
POSIX ERE
Java
.NET
Python
Ruby
XML
XPath

It is important to note that since these were developed somewhat independently, one should not trust on the fact that regular expressions for one tool will work with another, unless said tool is explicit in stating the standard being used. For instance, FTK and EnCase, use syntax similar to Perl. Without such knowledge, one may assume a pattern in one (grep with BRE syntax) would apply to the other, and evidence may be passed over because of such an error.V Though set standards for regular expressions exist,VI VII derivations from a given standard to incorporate aspects from other standards or to add additional functionality may be present and the lack of such should not be assumed barring the explicit declaration of software providers that given tools conform strictly to set standards.

A simple example of such a difference between different regular expression standards would be the pattern [a-z]\{3\} using the Perl and POSIX BRE engines. The POSIX BRE engine would match a string like “abc”, while the Perl engine would match something like “b{3}” literally. This is one of many differences between the engines that are available—because of this, it can be helpful, at least initially, to focus primarily upon one style of regular expressions, adjusting them when necessary, rather than attempting to explore the nuances of each in turn.VIII

Perl-style syntax allows the search of non-printable characters.IX Secondly, support for Perl regex is widespread, probably more so than any other regex engine. The GNU grep utility discussed in a later section has a -P switch signifying Perl syntax for the regular expression, saving the frustration of dealing with an entirely new syntax. Also, transitions from Perl syntax to POSIX BRE is both less likely to be necessary and perhaps easier than the opposite. The preponderance of tools explored in a later section of this paper have shared support for the Perl syntax as well. In the effort to make this paper easier to understand, non-Perl syntax will be eschewed when possible.X XI

Keeping this in mind, consider for a moment the regular expression syntax of the most popular engine at the moment, Perl.XII Perl is a scripting language, similar to PHP, most commonly tied to server-side scripting, dynamic web page generation, and a close relationship with MySQL.XIII PHP uses Perl syntax. On many websites, data is entered by the customer and sent to the server. If this data is not in the appropriate form when said data reaches the server, PHP can alter said data via three sets of functions: the preg group, the ereg group, and the mb_ereg group.XIV Of these, only the preg group will be discussed,XV and it is not even necessary to know either scripting language to comprehend said languages’ regex capacity.

The function preg_match(‘/cat/’,$string) would search for the phrase “cat” within the string $string. The single-quotes embody the regular expression, and the forward slashes act as delimiters:
CODE :

The result to the terminal would be “1.”

A slightly more complex expression might be cat|dog, where the expression matches either the phrase “cat” or “dog.” This is a very useful feature called “alternation,” the use of which will be shown later for searching for a number of different patterns at once.

Applied uses of regular expressions:

In a multitude of books available on the subject of regular expressions, as the book progresses further towards the conclusion, the example expressions seemingly continue to advance further and further in complexity. This is an example of a complex expression:XVI

(?=\d)^(?:(?!(?:10\D(?:0?[5-9]|1[0-4])\D(?:1582))|(?:0?9\D(?:0?[3-9]|1[0-3])\D(?:1752)))((?:0?[13578]|1[02])|(?:0?[469]|11)(?!\/31)(?!-31)(?!\.31)|(?:0?2(?=.?(?:(?:29.(?!000[04]|(?:(?:1[^0-6]|[2468][^048]|[3579][^26])00))(?:(?:(?:\d\d)(?:[02468][048]|[13579][26])(?!\x20BC))|(?:00(?:42|3[0369]|2[147]|1[258]|09)\x20BC))))))|(?:0?2(?=.(?:(?:\d\D)|(?:[01]\d)|(?:2[0-8])))))([-.\/])(0?[1-9]|[12]\d|3[01])\2(?!0000)((?=(?:00(?:4[0-5]|[0-3]?\d)\x20BC)|(?:\d{4}(?!\x20BC)))\d{4}(?:\x20BC)?)(?:$|(?=\x20\d)\x20))?((?:(?:0?[1-9]|1[012])(?::[0-5]\d){0,2}(?:\x20[aApP][mM]))|(?:[01]\d|2[0-3])(?::[0-5]\d){1,2})?$

The expression captures dates, times, and datetimes, including leap years. While this is a very comprehensive pattern and excellent intellectual exercise, the most useful and helpful regular expressions may be much less complex.XVII Additionally, the more complex the pattern, the more likely it is to fail, both on account of user error and the restrictiveness of the search pattern. Keeping this in mind, it is more useful to start with simplistic patterns and refine towards more restrictive ones than vice versa.

Knowing how to tweak regular expressions is more valuable than having a seemingly infallible set of regular expressions to fall back on; despite the advanced features of matching synonyms and fuzzed spelling in FTK, there are instances in which these fail and custom-made patterns are necessary.

What follows are examples of composed regular expressions and the application of several expressions in a forensic context.XVIII As well,this paper branches out to include specific instances of the utilization of regular expressions and pertinent information surrounding the use of grep in the context of Linux-based forensic investigation.XIX There will obviously be far fewer example regular expressions than could have been incorporated into such a paper, being as the number of expressions possibly relevant is limited only by the imagination. These were primarily withheld on account of a desire for a reasonably terse discussion about regular expressions in particular instances—books have been written on the subject which might serve to better elucidate readers of different expressions of pertinence. The references for this paper serve as an excellent guides specifically for regular expressions, as well as accompanying topics such as procuring forensic images with Linux, for any issue deemed by readers to be covered in insufficient detail.XX

Introducing Grep:

The grep tool’s usefulness comes from its ability to sift through data sets to match a pattern, making it well suited for forensic work.XXI Two common (not necessarily forensic) uses are as follows:
CODE :

ps -e | grep “ge”

This prints all processes (ps lists processes to standard output) that have “ge” in the process name.XXII
CODE :

cat /var/log/messages | grep “fail”

Prints the file /var/log/messages to standard output. This however is redirected with the ‘|’ (pipe) as standard input to the grep program. Grep prints out the lines matching the pattern “fail.”

Grep can be a capable tool in an examiner’s toolkit, especially if live analysis is desired on a Linux system. Since grep is very likely already present, it may as well be used.XXIII Exploring the implications of live analysis is beyond the scope of this paper, but note that using grep on a machine on which it already exists would likely alter little as opposed to the introduction of novel programs to a system.XXIV

Going back to the examples of grep’s usage above, the pipe operator is frequently used; the pipe symbol signals the shell to direct the standard output of the first command and use such as the standard input of the second. Knowledge of standard streams/file descriptors is required to understand the full implications of this. Most of the requisite understanding of such can be gathered from online sources.XXV

Concerning file descriptors, grep’s output is easily redirected to a file for later review.XXVI Frequently in examining a case, the output would be better read to a file. This is easily done, as shown:
CODE :

grep “greed” ./* > file 2> err

The ‘>’ symbol redirects this data to a file for subsequent examination. The ’2>’ directs error messages (e.g. “Warning: recursive directory loop”) to a different file. If you do not care about the errors at all, direct 2 to /dev/null. Many errors are helpful in discerning why a particular search is not working as expected, but it is possible as has been illustrated to separate error messages from ordinary output, both of which are, by default, written to the terminal.

Another terminal trick is as follows:
CODE :

grep “greed” ./* &

After this, pressing enter will return the user to a command prompt. It is possible via such to run multiple searches at the same time (it is recommended to combine this with redirection to a file). Typing “fg” will bring this background job to the foreground once again. This assumes the use of Bash; for other shells consult the documentation for similar functionality.

Concerning the topic of the three major forms of grep–grep, egrep, and grep -P—the last will be and should be used most frequently. The reasons for this are several. First, grep by default uses POSIX BRE syntax, which varies significantly from grep -P in that special characters must be escaped. This ensures for more cross-compatibility between regular expressions composed on the Linux command line and tools such as FTK. Next both grep and egrep do not support searching for non-printable ASCII characters such as spaces via \x20. Lastly, the selection of the Perl syntax with grep allows for alternation, which is supported under egrep as well but avoids the cross-compatibility issues.

Building expressions:

The following illustrates some simple searches with grep using patterns that may be forensically pertinent. Worth mentioning is that it may be helpful to experiment with expressions as opposed to simply reading of them. In EnCase, you may utilize the keyword tester (available in the tab for keywords when you make a new keyword).XXVII The following examples shall be formatted for the grep utility bundled with many Linux distributions—downloadable for no cost from many websites.XXVIII For the most part these examples may even be done via the use of a Live distribution—a bootable cd/dvd. The Bash shell is assumed.XXIX

The following grep will capture all jpeg photos in the current directory:
CODE :

grep -P “^\xFF\xD8\xFF” ./*

The -P switch tells the grep program to use Perl syntax, followed by the pattern of hexadecimal characters (using the anchor ‘^’, notably), and then the search path, which is all files in the current working directory. It is worth mentioning that something to this effect is done with forensic software that categorizes files via signature values—this is done via pattern matching as well.

Exif metadata in a forensic investigation may provide interesting and possibly crucial data pertinent to an investigation and serves a good example for something easily locatable with regular expressions. Typical attributes present in Exif metadata include camera make and model, date and time information, camera settings, picture thumbnail (oft utilized for display on a camera screen).

Some new, high-end camera models actually incorporate a feature called geolocation, which tags photos with information about the locality of the picture.

Exif metadata is typically distinguishable from a typical picture by ASCII text subsequent to the file header.XXX With jpeg files, a regular expression can be constructed to determine which files may contain Exif metadata and which don’t:XXXI
CODE :

grep -P “^.{6,30}Exif” ./

FTK and EnCase do not contain the capability to sort images based on this determinant.XXXII

Assuming a series of files are found pertinent to a given crime or circumstance, this may lend investigators the cause to search for and seize digital equipment not specified or justified in an initial search warrant.XXXIII

The following expression matches a large number of email addressesXXXIV:

\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b

A sample of grabbing an IP address with pertinent limitations: XXXV

\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b

An alternative form of this without the limitations of each octet ranging from 0-255, decimal, might be found in the following:

\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b

This would match IP addresses, but not have the added benefit of weeding out IP addresses like 400.600.800.900, which are impossible. Also, the ‘\b’ word boundaries will not work if there is a larger string within which an apparent IP was found. E.g. 123.456.78.9.123.456.78. It will match on this; one solution would be to do something like this:
CODE :

grep -rP “[^\d\.]\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}[^\d\.]” ./*

The following grep search uses the /dev/ entry and treats the entire device (in my case a partition on a USB disk) similarly to that of a single file. Thus, such could be utilized to comb through either deleted files or file slack:
CODE :

sudo grep -abP “hiddendata\!” /dev/sdb3

The -b switch will print out a byte offset. In this case it’s very useful to have being as its a whole partition to sort through.

This grep search was somewhat problematic on account of a possible bug with the -P switch, labeled as “experimental” in the man page of grep.XXXVI It serves as an example of the caution needed when testing expressions.

grep -P “baked(?!beans)” ./wordlist

To solve this issue, any of the following worked:XXXVII
CODE :

grep -P “baked” ./wordlist | grep -v “bakedbeans”
grep -P ‘baked(?!beans)’ ./wordlist
x=’!beans’; grep -P “baked(?${x})” ./wordlist

Keyword searches:

Regular expressions in any given case need to be flexibly adapted to fit the needs of the investigation at hand.XXXVIII An example keyword search might be as follows:XXXIX
CODE :

grep -Pr “(torrent)|(h33t)|(tpb)|(thepiratebay)|(demonoid)|(mininova)|(waffles)|(what\.cd)” ./

This might be an example of a search conducted on an individual suspected of software piracy. The search terms, separated by alternations (the pipe ‘|’ symbol), are names of common keywords pertaining to torrents, common file sharing tools notably not illegal in and of themselves, but commonly abused avenue for the sharing of illicit warez. The keywords can and should be adjusted pending the circumstances of the case.

The most will be said by far about this sort of pattern, as it is both powerful and flexible. The basic idea is to separate desired patterns in between alternations, so a match of any result will be seen. There is no feasible limit to the number of terms that may be searched for. In the effort to provide a means for the quicker development of searches using a large number of keywords, here is the source of a small php script designed to be run from the command line to hopefully facilitate the process:
CODE :

$argv[3]“;
else
echo “\n”.$g_query;
?>

Where the basic syntax is “[scriptname.php] [inputfile] [searchlocation] [outputfile]”.

Consider this example:
CODE :

php myscript.php input / outputfile.

This would run the script ‘myscript.php’, using ‘input’ as the input file, searching through the directory ‘/’, and using output as the output file for redirection. The actual output of the script would be as follows:
CODE :

grep -Pr “torrent|h33t|tpb|thepiratebay|demonoid|mininova|waffles|what\.cd” / > outputfile

For the input file, simply make a comma-separated file of the keywords. This sort of script is simple, and not perfect, but it works for reducing the workload on large or frequently used keyword-search type grepping. It should be mentioned that grep without the -P switch can do this with a newline-separated file, specified with the -f switch. The Perl syntax (-P switch) doesn’t allow for this, however, necessitating the php script to shorten.XL This was tested on sets of input keywords as large as 1411 different alternations. Regarding the speed differences between a search of 1411 alternations and one with many fewer, the speed differences were 0.0086250 seconds per alternation for a search with some ten alternations, and .004123317 seconds per alternation with a search with 1411 alternations.XLI While speed concerns are not a primary aspect of this paper, these preliminary benchmarks seem to indicate grep’s efficiency in handling large numbers of alternations.XLII The script could also append to a log-file of grep expressions.

It is not ideal, much could be added and changed.XLIII More special characters could be escaped in the same way that the ‘.’ character is already.

Grep and Packet Sniffing:

Grep with redirection (recall the discussion of standard streams) can be useful for several applications. The first reason, that has already been mentioned, is that the ‘>’ character can be appended to a grep command to write the output to a file. The ‘>>’ character can be used to append a later search onto the end of an earlier one.

Another viable use of grep could be to combine packet sniffing with a grep of the data. The command tcpdump is a tool also commonly found by default with Linux systems—no additional software is typically required—and this tool lets a user elevated privileges (typically) put an interface into promiscuous mode, looking at all of the traffic as opposed to only the traffic that is destined for the host.

Detailed information on tcpdump can be found on the man pages. Here is an example that will sniff payload data and write the the data to a file (called “data”):
CODE :

sudo tcpdump -vvv -s0 -wdata

The ‘-vvv’ switch controls the level of verbosity. On a typical DSL line running at 1.5 Mbps, the traffic generated by even a very short session of sniffing can often reach many thousands of packets (by very short I mean a few seconds). After dumping an adequate amount of traffic, Ctrl-C will stop the sniffing and return you to the prompt. Grep can then be used for searching through the captured data, as follows:
CODE :

grep -aP “how.to.kill” ./data

The -a switch here is used to tell grep to treat the file as text, and print out matching lines. Data captured in this way is frequently marked as binary data, in which case grep will not print out matching lines by default. The pattern might be used in an instance wherein a person has been suspected of plotting a crime (likely murder or an analogous crime in this case). This is quite rudimentary and only should be used as an example; a real case should account for permutations and synonyms of search keywords.

The method has significant limitations, the primary one being that tcpdump merely dumps data, it does not have built-in functionality to decode data. Examining tcpdump’s output will reveal data passed from source to destination and vice versa without any concern for whether or not such a format is in human-readable form.

Probably the most desired traffic is going to be web traffic—oftentimes traffic is left essentially out in the open for easy sniffing, often even with somewhat sensitive information being passed.XLIV The headers can reveal whether or not traffic destined from a given destination will be privy to easy observation via the use of tcpdump or not. Take the following two examples:

Encoded data:

HTTP/1.1 200 OK..Cache-Control: private, max-age=0..Date: Fri, 19 Feb 2010 05:12:16 GMT..Expires: -1..Content-Type: text/html; charset=UTF-8..Set-Cookie: SS=Q0=bmlnZw; path=/search..Server: gws..Transfer-Encoding: chunked..Content-Encoding: gzip

This was generated with a client that attempted a google search. Google gzips traffic, so searching for plaintext keywords in a grep will be fruitless for the payload of HTTP packets. Presumably this is done to save bandwidth from unnecessary traffic. Contrast such with the output of this header:

Non-encoded:

HTTP/1.1 200 OK..Date: Fri, 19 Feb 2010 05:11:39 GMT..Server: Apache/2.2.10 (Fedora)..Last-Modified: Thu, 18 Feb 2010 14:12:47 GMT..ETag: “4c07c-213-47fe08fb135c0″..Accept-Ranges: bytes..Content-Length: 531..Connection: close..Content-Type: text/html;

This would be an example of traffic to a site that does not employ gzipped encoding. The use of tcpdump with such a site would suffice.

It is important to note that gzipped encoding is not synonymous with encryption—tcpdump simply lacks the capability of dumping traffic in a form other than that which is passed along the wire.
If decoding traffic is necessary, tshark, the command-line counterpart to Wireshark, is a viable alternative. The following form of the command dumps fully decoded packets to the file “data2”:XLV
CODE :

sudo tshark -V -s0 > data2

Wherein searches would be performed against the ‘data2′ file. To users familiar with grep this can be significantly more effective than using Wireshark to accomplish the same thing.

To reiterate the point concerning gzipped encoding, tcpdump suffices when circumstances do not require dumping the full contents of packets. When full packets are required—e.g. to rebuild what a suspect was basically presented with at a given page—tshark is a much better choice.XLVI Tshark is also preferable to tcpdump for grepping network traffic for aforementioned reasons. Though neither will pick up encrypted traffic, tshark is able to decompress encoded traffic, allowing the use of grep.

In instances where web traffic is desired, often the desired output will be located in a section “Line-based text data: text/html,” so using grep is not necessarily mandatory, but the -b switch with a quick grep search may be helpful in locating which section of the file deserves examination. Another method to cull data would be to specify a capture filter, such as “-f “port 80””.XLVII

It’s left as an open question as to the specific instances wherein network forensics may come into play. Often, since warrants are served on crimes long since committed, it’s likely that an investigator wouldn’t need to sniff data off the wire whatsoever. It is a useful tool regardless, if not for the average investigator, then for the systems and network administrators.XLVIII

The Find command:

The find program can be used to search for specific types of files. The following searches for SQLite files (as identified with their common extension):
CODE :

find /home/ -name “*.sqlite”

SQLite files can often contain forensically pertinent information; one notable mention is that Firefox stores a treasure trove of information in SQLite databases. Some of this information includes downloads, form history, bookmarks and browsing history. By default this is stored under the .mozilla folder in the user’s home directory. The dot signifies that it’s hidden, it won’t show up to a ls unless the the -a switch is applied to ls when looking at a home directory through a live shell.XLIX

The following is a more complex example of find’s capabilities.
CODE :

find /home/ -type f -mtime -1 -name “*.exe”

In turn, the switches dictate to print those files (type f) modified (the ‘m’ in ‘mtime’) up to a day ago (-1) whose name ends in “.exe”. On a side note, files with .exe extensions are a rarity on Linux filesystems, and may even be a cause for suspicion in some instances. They are, however, becoming more common with the popularity of wine.L

Here is another advanced form of find:
CODE :

find . -name “*.png” -exec grep -lPa “^\x89\x50\x4E\x47\x0DA\x1A\x0A” {} \;

This time find is working on finding files in the current working directory with the apparent extension of “.png” and grep is testing to see if the files have .png file signatures.LI LII

One of the main advantages to using find is the easy of searching through additional levels of data such as file names.LIII The following command finds files with an apparent extension of .jpg in the /home directory:
CODE :

find /home/ -name “*.jpg”

This search is recursive by default. Notice that in this case, the “.” symbol should be taken literally and not as a regex token for any character.

Find can separate who owns what (by owner or group):
CODE :

find ./ -user root
find ./ -group root

Print results with a stipulation of time (in this case, ‘-mmin’ means anything modified less than thirty minutes ago):
CODE :

find /var -mmin -30

Finds files with permissions set to 007 (does not match 657, for instance)LIV:
CODE :

find ./ -xdev -type f -perm 007

This finds files which are r-w-x for world (the other bits do not matter):LV
CODE :

find ./ -xdev -type f -perm -007

Finally, find works well with xargs:
CODE :

find /home/toor -name “*.txt” | xargs grep -i “john doe” 2> /dev/null

The ’2>’ directs stream 2 (stderr) to /dev/null.LVI

Database and Directory Service Text searches:

The two examples that follow will be searching through a directory service (openLDAP) and a MySQL database; these are two specific examples of an almost infinite amount of permutations of specific circumstances that dictate investigating certain things. For example, a case involving suspected child pornography would have a definite emphasis on multimedia-based searches. Investigating a cracker would involve keywords surrounding such a subculture, and an investigation into piracy would involve searches tailored for such. These examples serve as a guide for how to treat cases with unique circumstances—patterns come secondary to knowing the ins and outs of how these services function.

Forensics of this sort are broadly classified as “database forensics,” and deserve a significant amount of dedication to fully appreciate what such a term entails. Books have been written on this topic, rightfully so. This paper is merely the tip of the iceberg about what may be said concerning database forensics—those wishing for more may consult the cited references.

Grep and find together can uncover a significant amount about a database or directory service. This becomes increasingly helpful with an increase in the amount of data. MySQL will be discussed first.

MySQL has differing storage engines that determine whether or not the following searches will even work. Differing formats will require differing searches. The one format that will be considered is the MyISAM storage engine and the .MYD and .MYI files. This format is purely chosen as a suitable example of finding data related to a MySQL database. Other engines and files types may be as follows, depending on the circumstances: .MRG (MERGE), .ibd (indexes and data for InnoDB), .CSM and .CSV (comma-separated), and .ARZ and .ARM (ARCHIVE).LVII

A simple command such as the following will suffice to track down most locations of pertinence to finding database files:
CODE :

sudo find / -name “*.MYD”

It may be necessary to run this as a privileged user. Locations in which MySQL database files are held are frequently under the ownership of “mysql,” “mysql” group, and as such will not be accessible to non-privileged users. If this concept seems foreign, find information pertaining to file vs. directory permissions.LVIII Alternatively, one could alter the permissions of files and directories recursively:
CODE :

chmod -R o+r,g+r,a+r ./dir

This would not be ideal, as it would alter finds based on file/directory permissions. Better to run all searches on restricted directories as a super-user.

There are three main types of files related to a single table in a database: .frm, .MYD, and .MYI. Typically these files are prefixed with the name of the table, such as table1.frm. The main value (to the human eye) of .frm files is that they list the column names of a table. .MYI files are indexes and do not allow for ease of grepping data therein (mostly non-ASCII characters). .MYD files are the main table files; they contain all the data held in a given table.

MySQL tables are frequently built using batch mode scripts that take administrator input in creating the table and the mysql program reads it in as if it were typed on the command line. One possible avenue for tracking these scripts down (there is no definitive trait of their filename or extension, though .sql would probably be something to try if possible) is to search for data likely to be present in such a file:
CODE :

grep -Pri “CREATE (TABLE|DATABASE)” /home/

If table backups are desired, something to the effect of this would suffice:
CODE :

grep -Pr “\-\- MySQL dump” /home/

This captures the typical output of the utility mysqldump, a common tool to dump a batch script for the backup of a database.

These aforementioned searches basically allow for a determination of whether or not a database exists, and if this is so, recovering perhaps some of the data. More complex applications might be recovering log files of transactions to recover and/or reverse altered/deleted fields.LIX This is beyond the scope of this paper as simple search tools cannot provide the sort of functionality by which to do this.

Directory Services:

Directory services are not the usual suspects for a forensic investigation, but given their sparse mention in the literature of the craft, it is useful to discuss such here to serve as an example of pattern matching for an unusual target.LX The directory service employed herein is openLDAP with slapd; other services differ but overall the commonalities should outweigh these.LXI

Assuming nothing is known about a directory service beyond the fact that it exists (perhaps not even that) on seized server media, likely the most fruitful search would be to use find to segregate any files with an extension of .ldif. LDAP Data Interchange Format (LDIF) files are commonly used as a form by which to load new entries into a directory via the use of a tool such as ldapadd. With openldap the configuration files are typically held (in Debian) under /etc/ldap/. The databases themselves are stored in a binary format elsewhere, under /var/lib/ldap. Files and logs stored in these locations are about as readable as a binary executable with strings of code interlaced with ASCII text.

Grep makes short work of locating specific entries within files once these files are discovered. Barring prohibitive file/directory permissions locating a known entry is no more difficult than including a keyword as a pattern, such as the following:LXII

grep “ou=xyz,dc=site,dc=com” ./input.ldif

A grep of the distinguished name typically works, as the distinguished name is written often in plain-text in files associated with ldap services.
CODE :

grep -r “dc=site,dc=com” /var/lib/

And the following will capture files with a particular pattern and copy matches to a particular destination:
CODE :

sudo grep -lr “dc=home,dc=com” /var/lib/ldap/ | xargs sudo cp -t /home/user/Desktop LXIII

sudo find /etc/ -name “*.ldif” | xargs sudo cp -t /home/user/Desktop/ldiffiles/

OpenLDAP and LDAP (and MySQL for that matter) are not commonly employed by the average user; there is not much documentation available for directory service forensics—until such a time wherein they are more commonly used and encountered in forensic investigations, directory service forensics is mostly a novelty; however, these principles are applicable to other, more viable, forensic applications.

Other Instances of Grep:

Though grep as a word is primarily denotational of the program, it has as well come to connote the general actions of finding information. Grep is as much a noun as it is a verb; additionally, many related programs have adopted naming conventions which are amalgamations of this word and that adhere to the original program’s spirit.

A few noteworthy programs are as follows:LXIV

ngrep: network grep, searches network trafficLXV
sgrep: searches for structured patterns using region expressions
pcregrep: grep that uses PCRELXVI
ext3grep: grep-like program designed to assist recovering data from EXT3 filesystems
agrep: this program stands for “approximate-grep,” and allows for a number of errors in the search pattern (fuzzy spelling)
beagle: provides indexing featuresLXVII

Foremost: Carving and Sorting

Until this point, grep has been used to sort through files allocated on a disk. Deleted or otherwise unallocated files have been neglected. Foremost is a tool that allows files of numerous sorts to automatically and effortlessly be exported from a dd disk image into another folder for easy viewing, separated by file signatures. Foremost’s invocation in its simplest form is seen in the following:
CODE :

foremost -i image.dd -o image.dd.folder

After processing has completed, changing directory into the image.dd.folder will show folders separating files by file type. If the standard signatures are insufficient for a particular sort of file, additional ones may be added in the /etc/foremost.conf file. Help is displayed in typical command-line fashion, with the -h switch.LXVIII

Simple Forensics Scripts:

Scripting common searches into an executable file provides an easy method for quickly processing media in a controllable fashion. In Bash on Linux (as well as other shells of course) typed commands can then be strung together an ran in analogous fashion to a program, wherein each line is essentially equivalent to a typed line on the terminal.

The following code is an example that accomplishes some basic forensics tasks.LXIX
CODE :

#!/bin/bash

echo “Example forensic script. Copies .png and .jpg files to specified directory. Verifies file signatures. Location to be searched passed at command argument 1.”

read pause

echo “working”

# find files with a .png extension and see if they contain a png file signature.
find $1 -name “*.png” -exec grep -Pl “^\x89\x50\x4e\x47″ ‘{}’ \; > ./picslist
# do the same to apparent jpg files. Append matches to the file picslist
find $1 \( -name “*.jpg” -o -name “*.jpeg” \) -exec grep -Pl “^\xFF\xD8\xFF” ‘{}’ \; >> ./picslist

# grep for patterns in the location specified by $1 (command argument 1), output results to a file.
grep -Pr “1337.haX0Rz|where.to.dump.a.body|murder” $1 > keyword_results

# find files modified within 10 daysand write results to a file.
find $1 -mtime -10 > modified_file_list

echo “complete”
# process results for display in browser via php script “sort.php”
php sort.php > test
firefox test
#optionally, remove temporary files
#rm picslist
#rm test

The accompanying sort.php file:
CODE :

<?php

//picslist has list of all picture paths.
$file = "./picslist";
$handle = fopen($file, 'r');
//$data = fread($handle, filesize($file));
$file2 = "./modified_file_list";
$handle2 = fopen($file2, 'r');

echo "”;
//process each path and print link to picture
while (fgets($handle) !== FALSE)
{
$data = fgets($handle);

echo “ Path: “.$data.”

“;

echo “

“;
}
fclose($handle);

echo “

Modified file listing:


“;
//this code does as above but with links to each of the modified files
while (fgets($handle2) !== FALSE)
{
$data2=fgets($handle2);
echo “ Path: “.$data2.”

“;
}
fclose($handle2);

echo “”;

?>

The power of scripting comes from automating anything that would typically be done by hand otherwise. Another easily automated task might be commands to make a forensic image:
CODE :

#!/bin/bash

dd if=$1 | split -d -b 700m – image.

cat image.* >> $2

This would take a specified device, image it in 700 MB chunks (unnecessary but helpful for burning to discs), and then concatenates the chunks into a single full image.LXX

The following would be a brief continuation of the former, making an image, hashing the result for verification, and mounting the resultant image to a folder and doing a grep search on it:

CODE :
#!/bin/bash

dd if=$1 | split -d -b 700m – image.

cat image.* >> $2

#dd if=$1 of=$2
cat image.* | md5sum > $2.split.md5
md5sum $2 > $2.md5

mkdir mounted

sudo mount $2 -o loop -oro ./mounted

grep -Prl “warez|piracy|torrents?” ./mounted/ > $2.grep.result

foremost -i $2 -o $2.output

nautilus $2.output

The $1 and $2 signify command arguments. After doing a chmod on the script file to allow its execution, typing in something to the effect of ./script.sh command1 command2 runs the file “script.sh” in the current directory, with the “command1” and “command2” passed to the $1 and $2 in the script respectively.

This creates a raw dd image comparable to FTK Imager’s raw image (the two resultant images can be verified to be the same). The image is mounted and then grep is used to search through the mounted image. Foremost runs after the grep search, and the folder is opened via nautilus for each viewing. Expansions/revisions upon this can and should be added per case requirements. Should circumstances necessitate compression, this can be accomplished with the likes of gzip, bzip2, tar, or similar utilities. Using gzip is as simple as “gzip [image name],” whereafter the image will be named [image name].gz when possible.LXXI

Linux as a forensics platform:

Hopefully by this point it has been shown that many aspects of forensic investigation can be done via the use of a no cost operating system, including imaging, file carving and exportation, keyword searching, and sorting by file types.LXXII Many versions of Linux can be had for no monetary cost, and the freedom to tweak and adjust aspects as needed are of a significant benefit especially in forensic investigations involving unique circumstances.LXXIII Proprietary firms that make and distribute forensic software are swayed principally by monetary concerns can conceivably leave investigators out to pasture if the latter’s needs are not matched by the goals of the former. The power and control over open-source tools allows for modifications and advancements beyond the concerns of closed-source software.LXXIV Brian Carrier also argued that open source tools more effectively meet the criteria for forensic evidences’ admissibility per the “Daubert test.”LXXV

Linux however may have higher barriers to entry than does Windows, in which case it must be determined whether or not the costs of a windows system (and the accompanying Windows forensics tools) balance or are outweighed to the benefits of using Linux. This entry barrier is solely on a per-user basis given the preponderance of investigators primarily dealing with Windows.LXXVI

One of the criticisms of Linux involves mounting drives as read only. On face value, this can be accomplished easily with something such as the following:
CODE :

mount -oro /dev/sdb3 /media/imaged/

However, a process called journal recovery with certain file-systems such as Ext3/4 and others may change the evidence. There is an option ‘noload’ or ‘loop’ that supposedly corrects this issue, but given the ease by which one may neglect to include it, and the ever-present concern of some unforeseen circumstance that might cause the kernel to write to the drive, it is prudent to use a hardware write-blocker.LXXVII LXXVIII

Another issue involves auto-mounted devices, such as USB drives and such. Typically, when these are plugged into most Linux systems, they are mounted without asking the user. Doing this with evidentiary media is a poor forensic practice in most circumstances. As mentioned, the best by far is to use a hardware write-blocker, but disabling processes that automount should work as well.LXXIX LXXX

An issue specific to grep is the lack of support for Unicode-16 and U-32, which shall become an increasingly large obstacle in proportion to the frequency of such encountered in investigations.LXXXI

There are some other criticisms to using Linux for investigations: Linux can’t see the last sector on a device with an odd number of sectors.LXXXII But probably the most salient criticism of using Linux as the primary forensic medium for most is the higher barrier to entry given that you must learn a good deal of commands and how to navigate via a console instead of GUI-based tools. This is no longer fully convincing with tools such as Autopsy coming onto the market; though Autopsy lacks the flair of EnCase and FTK, it does many of the same things.LXXXIII The detriments need to be fully explored by any investigator desiring a transition from Windows to Linux forensics tools—one need be mindful that any different operating system will present different problems.

Despite these criticisms, benefits of Linux abound. The first is a greater familiarity with a different tool set. Linux is especially prevalent on high-end systems. Four-fifths of the world’s supercomputers run LinuxLXXXIV, and live forensic analysis on one of these would be the worst possible time to acquaint one’s self with the basics of grep. Knowing at least basic knowledge of Linux lends to a greater degree of competency with non-Windows OS, including Mac OS X, Solaris, and others.LXXXV LXXXVI LXXXVII

It would be remiss to neglect the costs of Linux versus proprietary alternatives. Due primarily to the relative easy by which forensics investigations may be conducted with a license of either EnCase or FTK, coupled with a demand for forensics investigators that would be otherwise estranged from the field in lieu of such a productLXXXVIII, a premium has been (perhaps rightfully so) charged for the use of their products in the form of hefty licensing fees. Though this paper only serves as a sliver of the material needed to match the intricacies of competing products, if a community effort were to materialize around forensically-oriented concerns, it is definitely conceivable that EnCase and FTK would have a competitor selling software at an extremely attractive price.LXXXIX Need has brought forth such software as GIMP (free alternative to Photoshop), OpenOffice (alternative to Microsoft Office), and thousands of others; analogous forensic software is less a fantasy than a probable future.XC

Lastly, it has to be asked whether the field of forensics is benefited by a pair of relatively monopolistic businesses. Though this is enough to ensure healthy competition to further improve one product over said product’s competition, any enthusiastic programmer wishing to contribute to the effort is denied the opportunity to do so by the very nature of proprietary code. The arrangement at present primarily benefits the producers and not the users of forensic software.

Ultimately, the decision over which of these two competitors is better is left up to the reader’s discretion. In the future, hopefully GNU/Linux will become more a competitor to Windows as a platform of computer forensic investigation. Regardless of whether or not Linux gains significant market share in forensic software, additional option will increase the pressure to optimize software with additional features to benefit end-users.

Grep command glossary:XCI XCII

grep : program that prints lines matching a pattern. Equivalent to grep -G, for basic regular expressions (i.e. BRE)
Egrep : ‘extended grep’, equivalent to grep -E
grep -P : grep using Perl syntax. Most uses of grep in this paper use grep -P.
-r : recursively search through folders.
-i : case insensitivity
-f : obtain patterns from a specified file (one per line)
-v : select non-matching lines (rarely used in this paper)
-c: output file and ‘count’ the number of occurrences of the pattern
-a : treat all files as text. Use this to find data that may be hidden in binary files
-l : print name of file. Stops after first match.
-m [#]: stop reading a file after a certain number of matches
-n : Prints out the line number that matches the pattern
-A [#]: print # lines after a match
-B [#]: print # lines before a match
–exclude-dir=[DIRPATH]: exclude a directory. Useful for avoiding recursive loops.
-w : print all lines containing pattern as a word (the pattern ‘eye’ would match ‘eye’ but not ‘eyelid’)

Notes on Regex Symbols and Glossary: XCIII

Global: this term refers to an option by which multiple matches can be found in a given string/file. The tools mentioned in this guide are global by default. The opposite of this would stop after the first match.

Case sensitivity: determines whether or not a pattern such as ‘google’ is matched in the data “gOOgle” or “GOOGLE” or not. With grep, the -i switch can enable case insensitivity, in which case the aforementioned example would match.

Extended: This is somewhat an ambiguous term. It can refer to ERE, extended regular expressions, as in POSIX ERE, or more generally, to a feature that ignores white space in the searched data.

Dotall: this determines whether the wildcard ‘.’ will match newlines or not.

Multiline: most often pertinent in the scripting languages’ utilization of regular expressions, this determines the functionality of the anchors ^ and $, whether they are matched only by the start of the string and its end, or whether newlines will cause said anchors to match the start and end of each respective line.

Character classes:

. : matches any character
\w : matches any word character
\W : negation of \w
\d : matches any digit
\D : negation of \d
\s : matches a whitespace character
\S : negation of \S, any non-whitespace character

Character sets:
[\WxZ] : braces act as an OR statement, in which anything inside may occur for a single character. In said example, either \W, x, or z may be matched. May also be a range, such as [a-z], or a set of ranges, [a-z0-4]
[^abc] : matches a character that is not a, b, or c.

Special characters:

\t : tab
\r : carriage return
\n : new line/line break
\xAB : hex character (e.g. \x20 for a space, \x0A for a new line)

Characters which typically need to be escaped for literal match:

\, ., +, *, ?, ^, $, [, ], |, {, }, /, ‘, #, (, )

Anchors:

\b : matches a word boundary, typically white space before and after words, or the start of a line
\B : negation of \b
^ : matches the start of a string*
$ : matches the end of a string*

*: discussed in this paper what precisely this entails

Lookaround:

abc(?=afas): Lookahead. This would look for “afas” after the pattern “abc.” “abc” would not be included in the result.

abc(?!afas): Negated lookahead. E.g. if afas is directly after abc, discard the result. XCIV

(?<=afas)abc: Lookbehind. Does the same as lookahead but looks before a given pattern. An example of this would be "afasabc". The lookaround pattern is not included.

(?<!afas)abc: Negated lookbehind. If 'afas' precedes 'abc,' discard the result.

Quantifiers:

? : makes the preceding character optional. Works on any token.
* : matches zero or more of the preceding token.
*?: matches zero or more. "Lazy" match, matches as few characters as possible
+ : Matches 1 or more of preceding token. Greedy, will match as much as possible.
+? : Matches zero or more. Alternative form of *?.
{3} : match preceding token exactly three times.
{10,12} : match preceding token 10-12 times.
{3-7}? : Match preceding 3-7 times. Lazy match, will match as little as possible.

Grouping:

(cat) : groups tokens together in a capture group.
(?:cat): groups tokens together, no capture group.

Capturing groups are a way of storing matched substrings that can be referenced later. These are mostly useful for scripting (e.g. with sed and other applications)—less so for searching a hard drive.XCV

Alternation:

| : the 'pipe' character. Allows for the matching of groups. cat|dog matches 'cat' or 'dog' literally. To apply this within a larger expression, quotes may be used to separate groups. To match 'catog' or 'cadog', the pattern ca(t|d)og would suffice.

Endnotes/Citations:

I http://en.wikipedia.org/wiki/Pattern_matching

II http://en.wikipedia.org/wiki/Regular_expressions

III http://www.catb.org/~esr/jargon/html/G/grep.html

IV http://www.regular-expressions.info/refflavors.html

V Regular expressions composed for tool should never be carted over to another without significant testing. Taking an EnCase regular expression keyword search of any significant complexity and using it on grep with POSIX BRE syntax would be disastrous. There may not even be a warning, and special characters would likely be taken literally. Evidence loss would be a likely consequence.

VI http://perldoc.perl.org/perlre.html

VII The PCRE manual, available via 'man pcre'

VIII Another simple example of the various forms of regex is seen regarding delimitation. Expressions are often shown as “[abc]{3}”, [abc]{3}, and “/[abc]{3}/”, each of which may be correct or incorrect given the specific tool in use, even among a given standard (i.e. Perl regex). Because this paper principally deals with a few programs, many of these nuances are ameliorated, but their presence deserves mention.

IX This is not intended to imply that it is the only regex format to do so.

X Forensic article on Perl syntax in forensics: http://blogs.sans.org/computer-forensics/2009/04/17/forensics-and-perl-fu/

XI Any notable exceptions, such as grep without the -P switch, use patterns that should be comparable with Perl, PCRE, and other formats.

XII http://www.regular-expressions.info/tutorial.html

XIII PHP has a number of functions that allow access and use of MySQL. PHP and MySQL do not by necessity need to be used together, and the use of one does not imply the other.

XIV http://www.regular-expressions.info/php.html

XV The reason for discussing PHP in lieu of Perl is solely due to authorial preference, due to the fact that though PHP uses PCRE, this is designed to mimic Perl syntax anyway.

XVI http://regexlib.com/DisplayPatterns.aspx?cattabindex=4&categoryId=5

XVII Most searches will probably be for keywords. Even assuming alternation, these are relatively simple to construct.

XVIII There will obviously be far fewer example regular expressions than could have been incorporated into such a paper, being as the number of expressions possibly relevant is limited only by the imagination. These were primarily withheld on account of a desire for a reasonably terse discussion about regular expressions in particular instances—books have been written on the subject which might serve to better elucidate readers of different expressions of pertinence.

XIX Henceforth I will mostly refer to GNU/Linux as Linux solely to conserve space and due to habit. See Free as in Freedom for a better understanding of this distinction.

XX Readers unfamiliar with grep and/or regex should see the glossary of terms and the synopsis of the grep manual at their representative sections.

XXI Grep doesn't search through free space/slack space unless you specify the /dev entry. Doing this is admittedly messy. For a tool that helps with this see: http://www.sleuthkit.org/autopsy/help/grep_lim.html

XXII This search would be useless except on a live machine or for testing purposes. To stick to a consistent format, this will assume that searches are being done on a live system, as opposed to an imaged system.

XXIII Live analysis is beyond this paper's scope and should not be attempted without a full understanding of the risks involved.

XXIV Note that it would alter it somewhat. For instance, a history entry would be added to the .bash_history file of a live machine for each typed line in the Bash shell

XXV http://learnlinux.tsf.org.za/courses/build/shell-scripting/ch01s04.html is one such helpful source

XXVI http://en.wikipedia.org/wiki/File_descriptor

XXVII If one cannot afford EnCase, similar testing may be done with FTK or online at http://www.gskinner.com/RegExr/ . Also mentionable is JGSoft products, especially Regex Buddy, which is extremely useful for developing regular expressions.

XXVIII See http://www.ubuntu.com/GetUbuntu/download for one very popular distribution.

XXIX If these examples do not work, consider trying a downloadable live cd of Ubuntu Linux, on which these have been thoroughly tested. I am not familiar with the differences between Bash and other shells in depth.

XXX This is derived from experience and is not necessarily mandatory.

XXXI Due to the fact that I was unable to tease a clear answer concerning the precise location of EXIF metadata online, the broad range of 6-30 characters preceding its occurrence should suffice.

XXXII This feature was added to FTK 3.0 when “expand compound files” was checked in the preprocessing selection. I am still unaware of any such feature for EnCase.

XXXIII The reason being for this is that Exif metadata can be used to track down specific information tagged about the picture, such as the make and model of the camera. Frequently, these things are listed in readable format upon dumping the contents of a Exif-tagged image; utilities can parse out the less visible aspects, such as geolocation and timestamps.

XXXIV http://www.regular-expressions.info/email.html

XXXV http://www.regular-expressions.info/examples.html

XXXVI Fully, what the man page says is as follows : “-P, –perl-regexp experimental and grep -P may warn of unimplemented features. ”

XXXVII I'm quite sure this is a bug. Perhaps one reason for labeling -P as “experimental” in the man pages.

XXXVIII A regular expression for credit cards would have little or nothing to do with crimes such as media piracy. Additionally, any investigator doing explicit searches for material not related to the warrant that justified a given seizure of assets may end up jeopardizing the admissibility of any evidence found therein. So if the reasons why serious investigators should know how to construct at least basic regular expression searches has not already become plainly evident, perhaps now it has. Searching for things not dictated by a search warrant endangers evidence admissibility.

XXXIX The quotes are actually optional for this expression.

XL This script is most helpful over repeated investigations. It can save a good deal of typing, depending upon the number of keywords, and since keywords are saved to a file, they're reusable.

XLI This was done on a small test file, and would likely change a good deal reflecting this variable. Again, this example is purely illustrative.

XLII The alternations used to get to such large amounts (i.e. 1400+) were repeated eventually. The best test would be to use all unique alternations, as grep may somehow parse out repeated (identical) alternations, but I don't see this reflected anywhere in the documentation.

XLIII If of value, my script can be used with or without attribution, and altered by anyone in any way

XLIV This continues to be a serious problem for innocent end-users, as well as potentially a huge boon for investigators, though the former is much more likely to realize it than the latter on account of a general lack of specific interest and procedures in network forensics, while sniffing is realized to the fullest by criminal elements hoping to find low-hanging fruit, network traffic transmitted in clear-text.

XLV An intriguing issue with this is that oftentimes long lines of source code (such as is expected in pages that do not separate lines frequently, but rather mash them together so as to partially obfuscate the reading of the source) are “[truncated]” under the section “Line-based text data:”. This issue appears to not easily be resolvable, and should be considered in cases where full fidelity source code is desired in sniffing.

XLVI Wireshark too is also excellent, and is perhaps even easier to deal with for users without an intimate knowledge of the console (it is much more popular, probably due primarily to the GUI). The primary reason why tshark is being discussed at the expense of the other is that in many circumstances a GUI will not be available; these are often eschewed for their unreliability on servers. Tshark will be the only alternative as Wireshark requires a GUI to operate. Installing additional programs on a live system is almost universally unacceptable in the typical forensic context. Assuming that it is permissible, wireshark may be installed by the command “sudo apt-get install wireshark” (on Ubuntu and Ubuntu based systems) or “yum install wireshark” (on Red Hat-based systems). These commands should resolve any dependencies as well. If in doubt install Wireshark on the non-subject system and sniff traffic via a hub.

XLVII Capture filters are undoubtedly one of the most important features of a sniffer. The example presented captures all traffic, but as such, the resultant file can quickly reach huge proportions. Capture filters help to disregard non-necessary data from being written to the output file.

XLVIII In-house forensics experts might frequently come into gathering evidence. The following details one such instance where they may be needed: http://blogs.sans.org/computer-forensics/2009/05/07/deconstructing-a-webserver-attack/

XLIX Hidden folders and other small facts are thrown in throughout this paper; though extraneous to the paper's primary focus, these things become crucial to the minority of readers I imagine could be ignorant of them.

L Wine being a software program allowing one to run Windows programs on Linux.

LI http://content.hccfl.edu/pollock/unix/findcmd.htm gives helpful information concerning the find command

LII The file signature for PNG images is taken from here: http://www.garykessler.net/library/file_sigs.html

LIII Commonly referred to as metadata, or data of data. A simple example of this would be to hash a file and change the file's name and verify it once again. The data is unchanged, and the hash remains the same. The metadata has been changed.

LIVInvolves the use of -xdev, useful for not crossing mount points. Beyond the scope of this paper, more on this is available here: http://forums13.itrc.hp.com/service/forums/questionanswer.do?admit=109447627+1271729811024+28353475&threadId=1285730

LV A better explaination of this: http://linux.about.com/od/commands/a/blcmdl1_findx.htm

LVI Much more could be said about this. Do a man on xargs to start. There are numerous resources available online as well.

LVII http://www.cbtnuggets.com/webapp/product?id=508 Taken from “Managing Tables and Indexes Part 1”

LVIII http://www.dartmouth.edu/~rc/help/faq/permissions.html

LIX https://www.blackhat.com/presentations/bh-usa-07/Fowler/Presentation/bh-usa-07-fowler.pdf

Fowler also wrote a book entitled SQL Server Forensic Analysis that deals with database forensics in depth

LX The typical directory service can be thought of as a white pages; specifically, directory services are utilized in instances where reading is given precedence to writing. Directory services are optimized databases of sorts for reading over writing. Many applications of directory services involve user accounts and information associated with such. Directory services employ the use of LDAP, also associated with single sign-on capabilities that allow a user to access disparate aspects (e.g. different areas that require authentication) of a set of systems without having to authenticate to each of them in turn.

LXI More specifically, the commonalities of LDAP syntax should carry over into other programs. File locations and other aspect of differing programs will be completely different.

LXII This exact search is exemplary only. Barring a very big ldif file, this search wouldn't be an effective use of one's time.

LXIII http://www.cyberciti.biz/faq/linux-unix-bsd-xargs-construct-argument-lists-utility/ Good introduction to the xargs command.

LXIV These were taken from http://packages.ubuntu.com/search?keywords=grep and is likely not a comprehensive list.

LXV This paper has demonstrated features roughly equivalent to this program.

LXVI Given that the -P switch is built into grep, the use of this tool was strategically neglected from the larger portion of this paper by reason of the greater popularity of the standard grep program.

LXVII http://beagle-project.org/Main_Page

LXVIII More information concerning foremost can be found via man foremost or at http://foremost.sourceforge.net/

LXIX As this is a forensics paper first, and a software development paper second, I fully expect my code to be unoptimized.

LXX I got the splitting of images in part from this article: http://www.forensicfocus.com/linux-dd-basics

LXXI http://www.cyberciti.biz/faq/howto-compress-expand-gz-files/

Enumerating Bitcoin Nodes

Posted in Uncategorized on May 18, 2011 by z4klon

I came across an interesting not an hour ago. With my previous post, I thought I’d try to get a similar feel for who’s running websites.

This one involves significantly more nodes than my previous one. Nmap’s been taking some ten minutes to find web servers this time.

For starters, you have the file ‘bitcoin.kml’, lists all the IPs in KML format–basically an XML file with geotagging for Google Maps and the like. We don’t need all of this, so I made a script (similar to the one I used the last time) to get all the IPs, write them to a file:

import re
# open files
f = open('./bitcoin.kml', 'r')
new = open('./iplist2.txt', 'w')
f = f.read()
matches = re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}', f)
matches = set(matches)
for each in matches:
    new.write(each + "\n")
new.close()

The ‘matches’ set is important because it ends up reducing the number of matches in half at least. A python set is basically a list devoid of duplicates.

After that, you can run that list through nmap to get those servers running shit on port 80.

nmap -iL iplist2.txt -p 80 > output.txt

You could make this better by including the –open switch; wish I had done that.

Depending on how deep you want to get into it, you could just use firefox to paruse some sites of interest from this list. I decided to take it a tiny bit further, however, and get the IPs out of the output from nmap, so that I could wget all the pages I could in a single directory.

For that, I made yet another python script to prepend “http://&#8221; to each line in the file for wget to be happy:

import re
f = open('./websites.txt', 'r')
new = open('./webservers.txt', 'w')
f = f.read()
matches = set(re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}', f))
for each in matches:
    new.write("http://" + each + "\n")

This was just a modification to the earlier script.

After that, I went about wgetting as many websites as I wanted. I used a command similar to the following:

wget -nd -t 1 -T 3 -i webservers.txt

That dumped everything in a single folder, with a single try (the default is infinite, and since we didn’t do any checks on whether or not port 80 actually serves anything, it’s necessary), three-second timeouts, and reading from the file webservers.txt.

Welp, that’s it for now. Here is the massive list of IPs if you want to jump ahead to this point, don’t have python, or just want a head start to do some other sort of experimentation. This is of the whole enchilada, not just things that came up with nmap scanning port 80.

71.227.155.233
91.210.123.13
82.0.142.170
24.6.86.51
76.19.212.97
77.234.195.21
24.23.79.128
68.191.155.213
66.215.55.60
66.43.209.193
68.199.196.200
67.243.9.123
77.252.40.235
77.255.234.224
24.35.133.198
62.68.97.32
81.184.182.3
78.47.181.22
85.17.200.211
71.210.115.102
76.176.223.145
67.9.142.96
78.128.188.165
71.20.75.12
75.22.121.244
68.193.243.164
75.110.236.7
46.134.72.133
75.61.68.65
75.156.131.157
80.4.103.222
24.246.10.170
67.175.42.91
82.239.162.135
24.20.181.67
95.149.97.9
184.32.184.13
67.173.7.96
85.198.208.61
75.119.224.74
76.14.61.196
70.104.132.120
75.155.67.56
130.85.252.23
50.53.196.99
75.31.88.162
82.7.40.68
173.236.83.152
24.63.132.214
69.90.178.218
62.172.163.242
50.53.152.59
69.40.6.190
24.167.132.175
72.0.128.114
75.73.137.219
69.243.99.66
78.60.48.20
24.7.17.136
68.189.129.247
76.0.21.182
68.38.136.12
58.108.173.201
50.56.115.45
24.148.33.133
88.159.209.250
80.56.77.50
72.77.99.179
76.4.203.159
24.56.22.221
74.233.236.137
68.57.40.170
72.174.69.66
70.139.56.145
152.23.126.118
67.247.24.133
77.222.116.2
209.134.82.220
66.239.62.198
70.252.128.180
24.118.101.74
62.21.14.187
67.175.35.120
76.226.132.198
69.54.63.115
67.180.44.27
64.62.173.51
81.36.37.59
76.226.98.250
89.90.122.34
74.82.3.25
68.5.38.4
24.62.36.86
78.94.153.223
82.35.99.13
2.54.63.117
69.155.130.56
76.29.224.110
70.79.53.179
78.8.11.68
67.160.191.197
24.126.59.67
67.158.26.182
78.52.52.11
92.204.101.72
69.156.1.208
99.33.59.36
79.182.0.246
71.127.170.250
69.165.165.130
67.188.10.178
93.152.183.98
68.82.166.106
76.111.18.204
68.6.155.94
217.251.216.119
66.59.127.236
61.12.14.178
79.171.125.157
75.38.112.254
59.167.198.250
72.82.80.111
70.100.231.180
24.16.74.0
71.72.56.221
71.68.40.130
24.136.204.121
75.51.75.199
76.115.20.36
12.47.114.47
24.84.117.55
212.9.31.12
94.75.220.253
60.54.121.219
74.12.217.226
63.249.113.191
67.161.29.18
71.234.122.131
89.102.129.2
77.232.142.139
66.41.120.44
71.231.125.20
78.154.91.72
67.191.8.68
79.171.152.52
72.160.28.123
62.219.159.68
69.251.24.26
63.218.227.178
65.60.255.3
87.155.76.78
24.222.179.235
213.89.43.92
69.57.89.139
71.76.226.64
78.107.0.13
79.10.2.161
74.98.203.101
79.35.216.44
94.179.74.4
24.78.36.77
67.200.247.226
87.216.164.175
68.148.174.63
65.31.175.107
69.47.86.142
24.138.184.34
83.226.239.199
24.154.171.220
94.210.212.183
24.237.68.138
24.207.44.76
68.9.27.45
64.244.102.218
74.96.208.213
71.213.230.253
69.20.178.125
98.197.90.177
24.218.74.95
24.4.218.28
71.57.134.62
70.178.93.137
71.238.12.79
86.165.160.5
60.241.74.104
60.242.250.155
70.140.121.12
67.249.209.205
24.148.101.238
64.110.202.146
70.181.151.138
75.38.170.90
79.161.109.10
80.238.1.236
74.192.19.112
78.86.200.68
77.110.40.50
67.49.114.42
75.140.97.61
78.35.79.239
74.74.116.216
24.218.239.209
38.110.159.138
79.255.11.213
77.164.21.24
69.73.38.88
69.158.99.79
66.75.0.86
70.75.165.39
72.16.129.164
74.73.166.106
74.66.246.73
74.177.22.160
68.231.192.21
64.22.109.40
67.149.104.75
46.4.23.83
70.169.85.195
24.141.191.241
194.146.217.32
50.53.178.49
66.36.134.147
70.139.5.181
83.77.215.228
69.108.219.99
41.132.212.216
75.84.180.4
82.192.241.30
68.109.177.182
86.32.126.112
131.252.125.214
94.10.82.179
69.175.10.2
67.160.173.154
59.167.184.189
79.98.8.12
93.125.17.200
66.17.95.194
24.186.226.196
41.143.4.113
24.154.156.155
62.44.135.21
75.101.180.111
69.165.139.87
46.9.140.189
71.14.181.222
67.107.166.135
98.196.96.150
46.64.35.77
200.112.89.137
68.148.107.58
68.104.13.216
62.152.130.218
41.19.106.226
70.97.87.130
76.175.104.23
76.122.75.225
74.101.54.87
70.173.47.155
74.87.46.20
72.219.218.174
66.75.120.62
50.43.90.90
81.200.23.221
75.174.115.239
69.172.231.56
76.74.57.100
70.51.26.201
74.140.178.218
75.135.59.250
96.249.199.119
65.8.64.219
41.122.156.62
99.241.20.188
24.60.143.22
67.161.122.70
83.175.185.19
71.59.152.213
24.71.139.226
67.174.59.193
67.242.194.73
75.15.225.84
70.55.30.193
80.132.68.41
74.92.27.60
68.71.33.4
77.5.117.138
81.151.133.79
78.113.167.126
68.187.208.147
60.242.186.223
79.227.77.44
2.122.122.146
76.21.242.241
24.63.251.112
68.33.14.232
68.200.38.51
67.205.244.246
76.6.75.28
74.223.179.130
67.160.116.132
93.159.111.103
70.137.157.33
69.19.166.66
211.27.85.82
118.90.49.169
65.25.2.97
65.30.35.48
64.222.82.90
66.225.156.225
24.9.240.204
77.250.67.91
114.198.33.109
69.3.231.100
99.130.173.142
24.8.65.160
99.40.61.73
66.251.224.122
72.224.65.82
71.178.117.17
69.26.229.67
74.65.127.227
70.232.41.124
64.4.97.123
38.112.162.56
77.106.140.140
46.9.187.243
46.33.225.14
58.169.176.42
67.191.178.81
67.162.67.191
76.31.138.246
76.16.98.158
80.167.108.97
90.185.20.51
66.112.114.190
64.178.125.37
68.96.72.143
75.120.136.67
76.231.195.152
78.90.15.253
80.52.231.66
78.72.133.14
75.133.63.50
71.208.198.21
72.12.167.101
66.41.228.78
70.79.115.188
96.35.31.235
78.84.173.107
69.156.160.41
46.159.67.239
24.1.66.179
68.232.253.253
76.2.17.4
67.34.122.56
70.125.130.134
75.92.51.75
76.97.40.217
174.102.20.4
71.92.136.10
71.172.96.83
80.108.110.149
71.182.224.243
67.249.226.33
70.171.75.188
75.139.205.195
96.229.171.93
70.79.211.181
65.183.154.80
67.171.139.151
74.235.91.90
75.172.102.176
91.77.237.237
68.5.218.184
68.6.111.65
78.47.16.130
88.190.22.89
188.93.18.90
68.62.74.187
174.18.79.25
67.169.218.95
78.109.180.14
24.18.47.41
66.18.189.72
81.70.225.108
80.221.36.194
41.133.107.17
71.190.229.9
62.221.74.71
71.230.125.109
68.49.44.79
66.60.229.53
24.64.78.51
99.0.60.210
69.171.162.15
66.189.119.71
71.209.246.174
74.34.66.206
75.82.207.100
81.19.4.48
69.196.169.90
78.9.30.13
72.64.149.195
18.42.0.124
81.96.141.196
66.255.248.210
76.189.210.31
50.55.197.63
71.185.60.14
67.11.21.65
81.144.177.6
67.171.208.36
71.252.208.105
66.114.190.130
67.161.191.187
75.87.129.126
70.58.86.19
66.60.161.134
77.101.209.234
206.132.191.50
84.234.197.227
67.8.181.104
71.79.58.165
99.243.62.52
24.0.170.210
80.203.36.129
24.54.53.206
94.172.57.114
81.109.27.14
46.147.172.121
69.210.33.113
81.33.47.52
94.66.76.255
61.236.119.112
76.88.68.231
216.99.208.24
46.4.193.14
80.198.94.39
79.146.128.237
75.27.100.29
24.43.151.74
68.42.72.87
67.225.53.233
18.228.0.192
18.228.0.190
24.84.8.193
67.185.138.134
68.198.238.69
79.13.183.99
109.112.89.110
67.237.5.167
71.34.181.30
69.118.97.183
72.241.33.255
67.32.150.138
62.3.198.46
93.139.222.207
64.38.75.167
66.189.144.218
24.32.127.10
74.5.223.112
24.38.126.66
77.49.244.72
96.231.206.44
70.178.172.39
67.80.79.7
77.93.7.216
95.153.6.33
24.7.14.113
74.176.79.203
76.120.67.159
65.27.56.164
71.202.62.155
68.186.183.181
81.219.207.212
68.117.126.182
74.65.255.137
70.59.93.3
76.10.147.118
71.125.47.115
94.75.235.142
79.185.103.238
85.56.57.50
68.55.173.84
69.172.67.127
63.149.54.120
109.239.58.90
41.132.52.137
69.172.147.232
71.2.169.191
24.118.242.237
68.149.19.210
78.53.99.198
70.245.68.44
71.37.151.225
70.65.12.95
67.177.159.229
98.145.49.216
74.178.59.247
67.168.9.234
97.107.129.14
71.199.180.136
76.238.201.143
38.117.159.162
24.68.0.58
71.123.141.236
165.228.231.90
70.246.54.71
69.62.185.153
74.136.232.230
90.146.162.172
81.32.143.195
50.35.189.12
64.187.64.60
67.168.76.193
71.43.196.219
71.204.43.123
74.89.253.67
189.125.189.4
84.171.235.230
91.125.152.43
75.128.149.218
71.236.190.105
76.126.186.203
24.222.193.52
80.26.213.89
68.11.190.103
76.167.152.125
68.14.20.239
75.156.50.239
91.197.10.33
66.59.49.90
68.12.99.217
67.43.74.192
76.126.16.23
24.93.17.194
18.189.124.99
131.111.226.3
82.21.240.58
24.193.57.13
68.4.61.165
76.105.127.147
79.215.170.168
24.246.26.41
66.197.153.200
63.80.137.60
71.127.22.167
24.68.36.221
67.174.49.245
86.61.82.15
24.10.194.63
98.223.165.202
72.87.177.112
66.65.118.35
70.178.169.198
71.248.97.87
24.72.70.186
78.155.208.13
66.255.247.219
76.100.75.115
76.74.154.25
99.126.252.125
74.171.201.83
38.106.51.5
68.35.221.217
70.190.166.115
76.79.179.59
68.60.232.190
70.52.114.158
77.209.131.30
77.100.138.214
67.174.221.46
71.193.116.182
68.0.120.140
75.181.170.216
67.177.161.196
50.53.17.227
67.185.73.169
70.26.95.250
38.100.102.98
24.206.164.237
76.16.62.251
24.222.18.26
69.197.152.98
85.226.247.13
71.196.180.151
120.147.68.118
74.72.36.86
98.246.171.50
64.121.32.130
67.183.220.10
71.196.37.238
80.250.160.211
24.231.207.7
70.74.228.163
70.33.144.213
68.199.204.225
64.120.203.134
131.151.6.131
67.87.247.230
27.33.0.168
74.68.30.148
76.214.156.215
67.171.49.154
193.232.112.47
12.232.42.202
71.143.230.83
71.114.182.15
76.92.114.13
75.21.22.174
94.40.48.6
63.174.56.72
67.160.49.11
87.218.195.104
112.206.103.128
80.54.74.102
64.134.188.150
60.240.71.123
72.38.175.208
74.139.20.164
24.19.244.252
82.131.73.72
24.189.28.124
98.214.5.84
76.174.225.159
76.235.105.198
77.83.183.80
67.170.33.5
84.194.105.157
24.131.255.253
67.247.129.8
71.114.49.135
71.208.189.160
86.4.73.184
68.5.223.180
85.30.96.10
70.233.159.93
71.198.252.254
66.31.195.237
79.18.245.93
84.48.141.123
108.75.60.35
81.105.88.98
70.188.169.249
72.186.109.161
83.38.36.57
98.198.253.150
74.101.85.87
2.122.77.152
72.220.175.60
76.114.192.239
24.130.224.73
68.101.72.88
71.67.122.20
78.154.133.135
77.229.9.51
71.203.100.9
75.51.148.119
80.219.52.251
81.100.245.128
71.133.192.162
71.236.173.113
81.56.46.96
65.40.122.143
76.100.131.21
95.79.88.118
78.35.115.245
76.94.164.150
81.187.75.114
70.89.125.90
66.223.169.226
24.215.121.255
76.18.246.174
78.144.172.167
71.208.139.224
24.16.138.134
75.70.165.39
129.125.51.34
24.47.34.4
68.205.194.2
94.62.160.13
76.5.173.34
24.107.183.49
38.109.96.49
99.227.140.83
82.106.254.29
71.23.31.163
60.184.43.45
66.146.170.22
71.165.117.76
93.245.2.107
76.185.49.217
68.228.187.222
78.55.163.7
24.165.217.73
80.50.135.84
75.181.83.69
64.79.143.88
83.86.195.196
64.79.143.85
76.20.47.40
24.79.128.5
70.253.73.83
24.46.199.97
108.40.37.64
79.111.152.101
79.174.34.6
2.110.49.14
68.13.46.190
24.247.70.35
24.251.12.94
66.68.177.248
66.41.51.74
50.129.156.39
71.155.232.5
69.251.101.73
67.83.158.141
46.159.175.255
74.178.52.159
80.174.41.118
67.43.103.242
24.84.14.59
24.123.73.3
99.236.160.11
27.2.223.6
108.86.36.139
24.148.169.144
24.60.25.234
87.193.235.133
98.219.113.151
66.169.240.35
80.5.66.94
24.10.218.243
24.203.208.35
72.9.26.166
69.200.241.26
68.48.254.156
89.179.209.247
24.3.244.232
64.27.57.225
68.204.36.148
99.10.251.68
72.229.123.132
79.102.60.124
62.93.41.73
76.25.23.28
72.95.130.51
24.39.42.3
76.76.238.33
75.195.239.42
71.31.212.182
68.228.170.8
93.220.89.152
68.15.174.244
66.197.153.197
68.34.4.229
76.109.49.103
24.5.84.138
188.127.227.6
24.76.1.138
62.87.159.49
38.98.161.67
75.73.77.36
71.163.67.254
67.165.191.251
71.92.137.20
71.34.60.160
74.62.218.34
87.102.85.64
74.104.152.99
65.78.128.158
76.112.227.10
74.248.48.165
72.187.231.138
74.197.3.20
67.162.57.212
71.79.158.91
75.110.39.254
90.184.11.10
58.96.36.177
50.35.218.156
8.18.123.6
78.46.30.14
71.238.211.0
99.47.64.224
63.119.11.19
24.80.177.35
82.46.195.12
46.137.29.16
46.137.29.13
74.74.148.148
75.150.104.17
46.59.61.170
38.100.222.91
24.184.144.121
24.4.62.140
74.87.24.247
41.233.77.211
78.84.184.99
66.130.189.60
69.89.219.248
69.136.144.183
24.177.12.118
71.94.184.31
69.181.180.203
71.89.35.80
68.98.78.182
24.145.247.228
24.98.49.111
41.133.192.56
86.142.64.218
12.48.210.99
68.189.246.11
75.110.103.37
67.169.84.34
24.127.235.108
97.95.128.174
77.102.219.224
129.25.35.74
72.70.119.37
99.237.176.134
71.171.125.66
66.229.11.245
72.73.8.58
75.108.187.73
68.70.1.139
88.191.97.188
77.47.181.114
24.189.97.85
12.146.21.163
70.160.185.172
74.192.40.148
74.93.25.97
81.170.147.56
76.121.46.19
66.222.224.81
75.65.0.169
174.143.240.59
50.9.95.187
83.82.124.133
70.31.56.70
79.184.83.239
66.214.232.2
24.90.192.32
66.152.115.211
91.193.228.106
82.225.134.120
74.75.95.77
124.169.130.7
68.10.232.242
71.205.83.138
70.190.250.65
71.57.234.220
24.9.178.66
75.151.149.253
71.183.204.124
70.74.210.215
71.192.246.99
2.98.199.30
68.0.227.23
71.191.249.239
68.145.43.164
68.58.5.173
68.203.15.61
76.197.241.132
91.125.93.3
12.160.39.130
98.244.55.225
65.175.255.127
50.48.95.190
69.67.214.203
82.42.188.154
68.147.132.233
67.8.220.242
192.170.1.15
71.205.51.243
68.23.137.156
85.216.176.32
83.99.228.180
71.241.134.215
24.45.78.240
76.18.94.169
98.200.15.80
50.46.146.110
92.25.54.113
72.130.226.49
74.70.252.229
68.108.248.229
81.84.89.34
65.67.59.1
41.134.99.122
75.39.217.5
24.98.29.224
76.184.174.252
76.23.208.50
24.18.214.139
46.112.194.137
62.29.174.66
63.152.130.248
24.6.53.135
67.190.253.30
24.201.0.59
79.154.58.118
97.92.2.165
71.190.69.216
79.17.214.58
82.23.2.199
76.211.234.55
24.131.178.234
65.200.60.163
69.249.251.255
72.184.126.55
63.227.54.121
74.93.150.21
24.44.12.170
76.67.47.221
79.116.251.19
64.206.36.151
75.167.82.204
81.210.92.110
24.250.22.173
66.17.55.114
81.174.145.13
72.93.248.200
75.144.135.41
24.127.145.249
24.182.167.10
96.237.171.168
24.17.45.180
68.198.50.175
74.173.98.129
72.230.74.76
24.22.1.124
12.161.104.23
66.220.178.239
24.16.247.182
76.173.57.53
75.144.170.33
130.39.193.205
64.40.61.100
24.186.145.235
77.58.228.173
69.23.33.32
24.61.156.127
24.142.50.59
94.216.233.21
74.83.92.251
76.23.51.248
79.244.91.146
82.99.7.10
67.194.74.70
81.141.76.31
206.41.250.2
69.2.60.96
88.115.204.50
98.94.107.137
68.239.47.117
66.197.203.102
24.20.221.85
66.199.14.228
24.15.66.128
65.94.183.201
24.1.199.22
76.29.136.67
75.180.60.41
77.253.134.16
85.139.109.56
69.253.26.134
66.169.84.100
81.82.52.113
76.10.166.195
24.17.123.140
66.235.44.254
69.235.153.214
76.97.69.61
67.88.189.242
67.166.204.185
217.174.252.194
24.118.95.30
70.26.33.126
84.126.253.242
24.21.181.152
82.43.112.49
60.242.66.41
71.105.121.106
50.10.78.165
67.85.77.98
24.121.142.38
62.152.1.146
70.109.173.33
67.143.216.86
67.176.44.72
74.104.9.216
178.79.157.235
76.175.96.107
80.216.247.92
74.199.90.81
78.106.132.219
77.222.232.54
83.84.142.189
62.240.81.137
86.25.38.28
71.84.127.139
68.0.97.222
69.178.89.225
72.50.113.17
68.105.164.80
79.183.203.223
24.1.36.229
81.187.55.68
66.68.80.135
74.138.58.9
67.71.0.233
70.71.19.211
76.212.102.113
76.14.167.107
77.58.105.15
66.161.134.199
24.61.146.187
18.228.0.45
69.245.63.224
71.194.87.229
75.128.91.32
89.100.69.50
76.123.229.43
70.89.102.5
67.240.251.225
76.180.17.155
76.10.142.79
96.239.109.32
71.180.28.58
84.198.51.174
71.141.237.54
71.247.251.105
89.8.78.68
72.188.253.136
75.60.38.253
78.96.188.86
24.181.205.66
62.97.71.6
24.148.24.16
66.209.55.30
69.98.57.212
71.93.149.223
68.183.169.77
72.179.43.115
67.255.5.20
14.202.65.101
24.5.21.176
70.31.164.237
82.130.38.6
2.127.20.72
71.63.111.47
71.202.75.209
68.7.8.181
75.51.145.212
75.87.164.82
87.139.131.16
75.108.229.222
24.49.252.21
77.102.255.36
77.99.178.40
71.199.164.213
96.55.90.100
66.169.222.213
67.227.237.201
72.1.138.67
67.174.112.13
69.164.218.8
76.64.142.188
82.143.162.217
79.240.233.92
72.72.204.117
67.193.131.131
66.183.20.60
67.21.190.236
75.71.32.100
66.18.7.126
66.233.21.91
72.223.82.121
24.108.241.143
24.20.15.139
74.56.137.208
86.7.37.102
71.193.92.240
74.211.159.41
75.163.50.119
62.117.85.84
66.92.66.109
70.36.252.13
98.198.82.158
74.240.0.4
72.39.189.7
174.103.17.126
24.244.75.82
107.8.184.198
24.215.88.239
46.118.201.180
66.232.247.30
89.235.243.141
69.165.224.71
68.7.21.171
67.190.200.96
24.61.46.68
70.183.227.78
69.243.14.160
72.193.78.234
67.169.109.247
190.22.111.36
87.120.136.106
24.10.157.24
174.253.194.44
24.33.85.213
24.108.209.24
76.87.26.60
93.152.154.38
96.226.233.143
78.109.180.240
78.27.15.176
75.176.93.75
76.170.86.35
74.63.127.138
174.122.203.12
62.57.227.83
24.244.136.155
76.240.196.215
67.249.192.46
24.188.187.99
67.175.18.234
74.103.78.201
68.61.168.20
24.148.17.91
50.15.61.225
69.64.235.54
71.155.240.157
79.150.215.215
71.68.229.138
70.110.28.3
69.5.159.34
65.96.220.152
72.168.175.166
24.118.127.138
76.175.234.14
66.90.185.148
79.229.173.182
71.229.237.106
98.234.181.209
68.98.165.99
71.237.192.254
79.185.250.187
75.144.158.46
88.66.206.76
82.25.216.30
62.84.114.224
76.102.53.97
94.112.98.64
68.14.1.203
24.9.187.70
79.132.227.148
109.175.244.27
71.139.1.90
69.54.57.166
76.2.157.236
76.92.243.164
66.215.3.122
74.199.2.71
85.141.109.201
69.38.250.60
76.6.38.134
109.87.91.107
212.116.179.213
80.96.84.216
24.245.54.77
99.67.147.126
68.118.59.63
70.90.77.77
77.50.83.131
93.203.180.89
50.8.217.229
66.9.24.13
74.69.51.251
86.173.142.128
69.137.179.102
173.166.39.161
59.167.255.134
74.128.168.70
64.213.222.96
62.255.172.253
75.65.1.25
188.186.214.90
2.137.154.216
80.203.117.86
205.166.76.71
123.243.157.133
2.82.93.79
96.38.241.66
85.179.67.205
24.87.24.15
67.58.77.138
74.196.180.87
81.234.241.81
208.86.224.151
83.134.107.136
72.234.132.225
72.1.197.242
77.13.157.175
67.8.102.212
24.192.5.40
77.126.17.8
46.12.200.176
72.54.243.226
109.205.248.5
41.57.137.164
24.144.176.10
70.112.235.54
81.232.9.193
76.127.226.163
63.228.59.9
69.23.244.175
75.170.7.69
24.185.47.79
67.182.213.3
84.248.162.57
62.155.224.169
75.17.240.20
67.171.116.188
74.100.97.158
76.119.140.224
67.168.205.121
69.141.95.92
81.83.2.9
75.42.218.79
68.5.218.69
50.72.138.113
99.44.228.14
72.50.27.208
76.18.4.160
81.230.131.99
84.16.208.132
69.115.222.59
24.241.98.117
65.48.197.101
68.186.241.171
74.192.213.97
68.33.62.142
71.40.204.30
66.67.125.27
79.136.36.225
194.90.216.222
59.189.45.144
68.8.200.82
50.43.56.242
67.188.10.190
71.13.38.96
109.224.138.60
68.3.198.47
67.173.226.47
24.216.54.84
81.187.127.199
130.89.165.8
66.229.41.68
80.68.68.67
190.101.27.70
67.169.129.27
75.76.175.90
71.154.158.24
69.54.193.228
24.205.235.149
50.81.155.122
81.167.58.17
12.205.240.191
18.189.100.167
72.11.200.131
68.5.55.62
76.102.217.112
67.217.10.165
46.31.75.2
68.148.148.83
71.241.242.38
68.114.250.176
78.147.252.20
86.198.138.202
59.101.178.243
66.87.0.172
67.189.115.6
67.172.89.251
70.232.167.235
77.37.204.152
68.41.99.101
74.185.20.188
12.19.29.200
74.67.81.196
70.178.116.245
24.239.194.143
66.76.180.58
84.233.160.78
71.23.173.169
78.86.0.25
71.48.5.175
67.80.93.55
74.176.176.43
71.29.113.109
98.111.31.230
88.218.142.132
91.108.219.12
81.174.146.185
63.225.167.65
72.54.40.206
24.30.112.147
94.237.68.123
67.188.128.7
94.179.23.63
70.36.235.17
92.147.17.180
24.224.153.118
71.155.148.157
61.69.239.103
76.209.220.229
76.238.172.166
68.192.103.236
74.210.120.91
74.75.8.86
173.165.105.161
70.26.83.91
89.14.215.233
24.251.46.112
118.92.2.28
41.145.159.19
92.4.133.90
24.129.118.159
89.0.6.132
24.217.132.10
75.111.151.91
85.82.221.176
69.3.101.52
80.42.154.191
40.0.61.128
69.196.160.97
75.121.65.137
82.95.164.45
68.170.178.2
80.0.150.139
79.184.96.26
71.70.225.185
70.176.131.223
67.90.36.98
24.17.162.148
70.27.26.108
83.27.1.148
71.31.48.45
76.26.166.138
80.216.182.121
78.129.202.41
190.97.11.163
69.54.146.218
70.66.33.31
50.16.46.232
64.199.136.162
66.91.2.4
69.128.42.2
72.201.76.205
62.93.117.89
75.66.21.31
72.177.145.173
2.94.194.200
62.75.181.164
70.52.251.54
24.202.212.30
98.240.193.215
65.31.216.165
71.170.202.71
78.22.76.234
24.213.72.134
70.44.28.163
24.73.167.82
71.15.119.48
76.76.236.67
77.97.88.93
74.105.20.83
68.99.115.42
69.153.134.235
71.192.28.65
70.176.228.16
90.193.78.83
2.218.182.209
67.240.120.46
24.11.193.250
66.190.238.78
24.112.133.173
76.180.60.168
95.20.26.187
67.84.142.238
74.42.163.211
68.81.120.95
80.176.148.244
68.185.171.188
24.73.118.66
76.102.12.23
65.92.102.121
24.5.2.223
84.209.25.181
96.22.122.115
91.66.148.142
67.201.194.49
41.112.157.251
24.4.58.59
75.20.135.8
79.136.5.218
24.208.90.199
89.33.63.17
75.135.73.93
76.172.216.51
67.183.177.144
75.117.79.206
69.91.186.150
72.207.237.198
69.46.35.5
94.42.36.184
74.90.21.23
89.16.174.254
46.109.12.77
86.156.176.101
24.5.74.221
70.126.106.14
63.249.43.222
70.27.25.57
24.85.179.244
79.160.173.76
94.254.37.218
68.57.75.99
64.111.209.175
78.21.33.225
75.74.15.146
85.31.189.252
81.190.220.11
65.38.41.17
89.0.41.181
74.73.182.82
24.83.9.72
24.186.19.152
24.22.209.99
58.182.108.249
70.60.76.34
84.52.175.74
78.28.123.37
71.170.31.27
78.16.228.23
75.150.121.105
75.173.92.54
68.200.159.142
77.78.155.48
24.90.211.125
71.197.114.79
24.131.156.106
70.114.46.196
69.230.66.211
59.167.111.22
208.111.39.154
66.218.202.222
72.179.49.221
76.120.12.154
82.232.99.208
68.175.32.236
65.196.228.2
71.183.204.48
70.234.139.27
69.49.114.10
64.22.204.6
77.87.35.206
76.97.93.92
74.60.1.68
68.99.45.209
67.183.214.21
98.207.76.233
80.6.234.28
79.149.211.175
67.45.96.168
69.64.34.118
24.29.242.233
66.108.60.186
69.209.198.179
75.194.249.130
67.160.116.229
71.145.164.197
64.126.34.196
94.166.153.122
60.240.141.168
70.82.66.115
77.56.182.47
70.177.219.52
77.86.91.5
107.33.235.195
71.205.182.143
74.111.24.103
75.73.5.171
80.50.133.50
72.135.109.59
91.121.177.64
69.249.178.56
68.55.167.238
71.196.69.96
76.171.16.186
91.206.142.19
66.213.138.2
66.41.246.216
79.43.235.208
72.243.208.125
75.36.187.15
99.71.92.41
76.97.46.106
76.14.64.147
71.57.179.67
69.153.49.234
67.240.81.29
76.126.227.49
81.187.117.20
70.161.111.184
203.217.57.119
38.101.213.100
63.126.183.110
64.71.8.50
84.16.230.215
70.51.114.156
67.193.252.74
24.85.132.114
76.172.152.159
66.233.159.240
173.74.83.101
71.201.139.71
70.168.62.101
79.102.181.22
64.74.213.98
79.126.167.211
68.193.158.171
68.107.31.188
96.48.194.59
70.188.1.129
62.245.107.119
97.107.138.206
24.63.244.150
69.61.223.138
70.63.111.50
81.220.120.182
72.91.79.199
78.16.121.194
68.194.84.0
24.213.0.3
75.100.79.153
84.48.218.156
74.197.77.31
75.72.0.118
83.7.242.230
81.165.74.244
75.70.79.36
24.23.240.173
68.173.8.177
76.113.136.250
67.81.148.80
81.23.49.179
68.60.93.244
64.136.211.103
94.193.47.207
78.86.154.26
71.162.118.207
65.127.115.234
24.23.118.244
77.255.226.80
72.197.198.159
76.245.46.75
99.97.163.87
12.71.233.34
68.48.50.11
67.251.99.245
24.11.102.119
72.25.97.102
46.9.6.86
75.151.233.57
75.181.46.211
41.132.115.173
69.57.127.130
76.123.9.42
195.178.171.162
70.44.122.140
65.75.84.225
86.163.251.197
75.97.13.202
71.58.76.218
80.161.85.77
64.207.241.163
71.236.251.43
66.148.120.157
71.83.211.101
66.148.120.159
77.87.35.28
78.148.24.27
131.118.230.1
77.102.185.129
46.188.8.2
77.188.195.67
71.187.193.68
67.165.36.160
69.207.71.123
24.250.158.93
75.34.80.86
67.183.206.128
66.94.91.58
70.73.32.186
24.176.72.198
80.3.77.135
66.222.1.26
81.204.0.240
65.67.88.226
46.119.68.215
90.43.188.46
71.223.113.15
74.184.117.174
70.27.128.33
72.43.17.210
98.157.94.196
66.49.130.23
50.19.47.232
76.115.2.116
76.248.243.203
74.124.97.4
66.117.227.8
66.112.185.20
76.201.149.110
50.74.24.138
67.84.94.215
67.185.169.204
71.55.213.37
76.185.134.16
74.216.10.216
76.171.141.254
72.38.218.114
65.31.208.177
74.85.82.201
74.243.4.199
80.254.73.24
24.3.103.82
74.95.196.37
75.30.95.56
74.118.73.99
92.233.20.230
96.50.193.124
75.175.98.98
82.39.176.69
24.154.156.214
71.50.2.185
98.125.214.141
71.192.47.66
69.60.13.225
41.0.131.17
209.187.238.135
64.121.122.33
38.121.78.66
75.25.122.165
50.53.161.47
24.143.108.155
24.253.2.138
60.241.11.63
71.193.198.146
75.37.205.102
79.184.138.235
99.36.57.16
67.204.7.31
24.126.173.239
79.224.235.81
66.47.228.68
24.237.140.4
66.69.195.145
68.232.118.216
70.242.226.212
76.97.191.11
94.178.27.1
76.175.129.115
85.65.189.200
98.219.214.99
65.30.187.96
78.82.129.136
58.164.43.214
68.80.131.16
72.27.43.36
71.104.221.92
66.191.176.83
24.246.68.234
69.166.166.217
76.176.54.212
217.142.134.19
91.153.239.197
68.32.53.168
2.25.135.202
24.161.186.32
75.176.90.64
66.57.45.87
70.59.42.141
71.102.252.181
72.208.116.110
74.68.117.148
83.87.144.14
72.229.126.44
184.18.141.88
173.61.131.42
68.111.252.55
81.171.144.50
76.126.147.219
66.76.90.1
24.214.198.103
69.74.168.162
72.208.13.122
81.97.186.193
77.58.202.114
69.17.30.155
64.222.112.248
76.178.80.217
24.205.235.104
74.243.146.253
96.28.210.230
75.127.178.18
67.175.193.191
64.68.165.166
76.167.166.132
84.231.183.34
66.190.57.240
74.101.158.16
60.234.234.36
91.193.253.53
64.22.103.150
93.37.149.241
78.151.160.208
66.214.246.154
74.171.97.116
68.46.69.202
50.47.149.188
76.113.179.114
72.187.119.104
77.238.201.30
80.77.243.22
72.178.89.168
66.190.128.52
71.30.4.95
66.114.33.49
70.90.189.209
24.235.123.162
75.25.119.95
78.31.158.217
38.110.6.187
93.104.144.79
68.80.24.38
58.110.165.193
64.121.175.95
71.236.33.247
77.87.33.198
64.22.235.205
169.232.71.70
74.160.81.21
64.187.64.40
24.207.118.249
46.162.91.203
76.27.55.229
76.182.35.136
66.87.0.139
68.229.152.192
70.30.84.213
24.61.176.163
2.216.198.232
72.213.139.181
2.26.24.194
62.34.86.70
71.182.189.226
128.208.70.36
66.54.191.252
66.27.85.168
79.221.13.144
87.178.173.95
72.166.164.5
66.30.7.15
24.150.131.156
71.243.195.105
94.231.60.3
65.51.23.226
85.183.206.139
79.183.39.36
66.8.152.121
75.1.64.80
65.74.103.82
46.0.149.191
76.122.160.250
68.42.181.128
69.61.198.14
93.198.1.22
76.236.126.34
71.232.216.8
75.69.69.197
65.9.145.124
77.87.202.81
85.64.18.171
68.12.221.3
69.34.225.196
71.60.48.141
69.65.5.30
81.178.176.151
71.199.92.129
66.112.248.210
71.227.158.62
74.65.185.226
80.236.234.249
62.163.222.102
74.125.121.65
71.234.165.109
24.249.250.84
71.210.36.4
72.90.77.181
81.129.10.174
189.13.82.79
67.171.33.120
24.4.7.200
66.75.245.43
71.183.231.186
71.192.205.129
62.235.163.203
173.203.210.245
67.186.84.69
65.93.200.210
24.3.150.63
78.12.187.246
68.38.10.192
212.79.119.61
67.139.173.204
68.204.124.46
72.94.21.215
71.62.227.189
75.119.228.63
71.231.158.136
83.58.74.210
50.53.37.112
24.19.58.26
68.68.97.90
80.5.215.111
75.99.255.186
24.150.128.42
80.3.184.14
75.145.74.29
46.43.50.164
78.110.196.13
94.175.136.115
70.139.198.137
87.59.245.54
59.96.64.214
72.200.125.119
66.192.104.10
91.128.200.106
184.57.4.28
80.67.176.176
78.226.14.211
67.162.83.190
97.77.78.14
85.164.109.50
67.184.208.113
68.38.178.64
63.248.233.2
66.134.50.27
128.120.170.23
67.170.12.54
12.40.51.34
66.116.103.135
81.234.202.117
75.60.31.173
12.51.113.34
71.235.206.31
69.140.102.229
74.36.97.39
62.169.208.213
85.17.236.80
24.123.25.158
62.118.157.233
71.80.21.154
71.195.2.122
68.42.49.27
80.137.100.148
78.58.194.212
76.100.225.149
2.221.62.13
24.118.77.201
184.106.155.62
68.43.26.219
77.22.58.155
66.143.21.253
71.229.231.23
83.227.128.137
1.64.63.194
178.183.232.46
24.214.163.59
24.105.155.19
72.253.148.96
70.46.228.2
24.130.154.112
70.88.123.176
81.153.201.195
76.179.204.135
77.177.37.2
62.143.155.99
69.50.13.106
67.166.47.21
190.79.151.151
67.177.96.185
77.10.82.108
64.183.158.138
78.16.32.83
68.84.72.84
87.98.218.65
67.180.208.157
68.40.122.54
46.44.49.144
69.253.164.12
24.15.135.95
74.228.195.42
178.235.25.3
98.204.84.54
79.246.70.209
24.232.113.116
69.254.3.185
82.55.224.72
75.142.201.146
12.2.223.230
76.122.138.250
74.193.30.182
71.127.49.11
74.96.245.100
72.183.58.3
24.201.248.12
71.164.94.117
72.20.180.8
83.83.60.153
67.240.169.198
41.132.109.97
66.141.234.54
80.171.117.228
66.208.175.196
76.115.134.75
24.222.166.50
70.190.25.166
62.142.192.14
62.219.154.229
76.178.240.13
81.37.82.159
76.97.60.22
109.75.176.70
80.126.50.62
77.114.226.11
74.61.19.211
70.130.140.111
71.32.209.38
67.241.244.68
71.58.74.100
86.14.68.57
80.218.205.186
68.48.142.60
99.91.224.239
67.248.244.202
66.49.54.242
71.205.81.7
199.21.244.99
87.4.226.188
68.104.105.189
98.237.242.165
67.217.170.79
98.210.197.103
68.185.190.98
66.135.38.238
24.78.227.30
71.221.118.213
46.5.29.77
98.250.173.76
66.38.66.72
71.202.25.41
71.183.221.74
72.128.31.177
67.171.106.45
70.185.99.84
98.239.91.64
67.223.228.107
77.5.32.247
75.197.247.117
81.98.52.162
62.82.138.130
72.39.124.248
68.177.208.11
173.48.97.240
79.186.12.235
76.240.19.195
76.204.96.3
72.45.229.26
70.189.135.85
78.87.98.166
67.175.209.91
96.255.35.122
76.226.151.11
46.159.157.25
75.151.247.209
78.73.42.200
71.191.157.14
18.237.1.8
76.21.17.214
76.230.5.6
69.243.107.164
68.99.249.127
71.192.96.2
67.90.153.130
71.33.55.95
76.111.62.168
79.84.134.101
24.108.236.105
24.181.182.8
67.182.179.138
75.185.33.5
173.246.200.94
64.198.7.98
24.4.126.67
58.28.153.36
173.19.50.17
75.10.140.50
76.186.101.173
81.193.251.3
69.146.100.69
74.133.2.222
72.187.71.187
71.126.248.100
80.91.36.11
64.202.229.91
62.147.184.171
60.242.209.171
69.60.115.76
24.151.94.63
67.50.84.126
60.234.215.176
74.230.35.72
50.46.194.136
80.68.90.169
87.154.110.24
75.144.15.165
77.11.83.55
72.193.191.254
50.10.104.45
65.220.25.61
81.24.208.206
71.204.27.114
71.211.114.117
2.103.49.30
24.27.19.184
64.47.157.42
69.137.245.121
74.109.254.15
80.203.26.133
81.105.33.193
71.224.120.205
92.231.168.93
68.15.192.252
79.148.49.34
64.135.203.231
71.215.119.53
70.83.117.7
98.240.84.255
85.214.239.4
98.173.38.54
64.247.138.120
71.209.199.82
66.31.88.163
83.99.203.204
71.227.129.98
132.212.18.146
69.47.216.176
82.101.244.149
66.190.238.92
76.166.175.171
24.193.79.85
69.107.89.221
78.105.240.78
27.32.81.20
76.181.139.234
24.84.64.122
67.170.172.115
66.169.180.214
24.4.101.215
74.44.180.134
67.220.34.54
24.9.78.28
63.228.160.54
68.200.237.97
8.3.224.32
68.3.168.185
84.63.3.32
69.158.24.165
78.146.53.182
84.253.247.173
74.95.36.145
24.239.222.30
63.119.101.248
76.26.52.154
69.181.131.232
69.105.84.78
50.17.1.140
74.115.199.33
24.75.77.236
71.66.255.227
68.4.1.152
98.217.198.5
71.230.169.34
66.36.135.238
72.55.75.78
67.170.151.229
68.57.104.203
137.99.222.62
67.3.131.235
77.255.70.176
66.57.69.253
188.40.81.8
79.54.90.9
71.202.188.25
62.253.141.247
173.75.223.213
24.251.205.206
70.116.144.25
78.34.69.123
76.25.209.23
24.126.204.219
69.165.217.2
66.30.167.189
24.13.126.200
66.234.199.82
63.148.193.214
66.17.89.2
66.31.203.81
69.80.103.147
89.76.91.179
69.50.15.20
68.99.79.60
76.87.34.70
74.104.32.150
46.4.15.253
72.24.172.61
76.23.125.219
68.8.85.52
74.170.125.112
75.73.49.93
67.207.96.206
79.97.150.10
77.99.62.64
67.233.191.121
67.167.73.147
46.109.166.42
64.135.81.154
78.73.89.241
67.181.12.53
95.172.18.250
68.4.123.186
2.132.26.248
69.214.4.149
24.80.238.65
184.53.167.231
79.125.35.242
24.86.194.42
75.83.178.36
99.154.152.86
62.78.223.30
62.15.226.33
68.61.149.241
65.216.227.62
65.34.113.159
74.134.33.232
71.227.103.134
77.78.180.55
74.67.50.19
71.127.53.126
76.123.205.214
60.240.243.28
80.127.146.215
67.166.29.163
74.195.254.219
67.249.140.64
76.182.241.10
41.132.42.111
98.232.221.227
24.56.234.143
74.202.90.2
72.49.251.29
86.142.219.243
65.111.99.188
24.83.165.114
24.67.56.8
70.31.55.137
71.63.132.127
67.162.132.83
64.134.157.11
75.39.30.236
69.207.177.236
68.117.125.194
68.2.210.185
76.102.16.125
81.231.87.245
81.37.182.66
75.132.140.143
75.33.187.64
76.116.1.235
59.125.159.55
94.42.140.19
68.230.83.216
68.231.76.180
72.221.82.216
69.89.102.140
64.22.109.214
72.229.137.69
66.151.32.135
99.243.190.182
75.57.74.88
75.191.170.17
72.185.61.99
50.53.102.60
66.129.224.36
90.209.150.37
80.72.44.220
68.6.201.109
62.21.53.6
89.222.134.190
76.28.125.76
67.165.93.74
24.192.105.105
24.4.74.185
68.51.41.118
72.208.138.94
74.110.150.39
68.114.200.96
50.43.101.34
72.234.175.163
64.111.160.25
75.206.74.86
67.163.58.7
98.237.52.37
74.104.144.124
74.104.144.125
186.204.129.88
98.201.10.84
81.57.39.160
89.100.31.5
63.133.206.2
74.136.89.222
74.79.160.173
67.188.197.119
66.203.195.215
24.42.107.208
64.27.57.122
74.208.73.101
69.10.121.138
203.167.243.98
72.78.102.163
79.33.56.194
74.192.113.140
24.203.150.8
71.237.127.49
71.251.59.173
24.253.225.195
59.189.92.155
77.179.117.215
76.20.122.2
68.13.220.60
24.46.115.238
24.237.24.39
71.169.181.252
68.80.30.239
85.217.216.22
78.58.202.121
75.160.66.142
86.82.4.42
76.109.132.62
74.70.26.84
70.50.188.31
67.84.52.239
24.64.84.245
79.185.27.101
24.246.60.36
46.7.31.191
24.228.26.241
75.72.35.162
81.22.244.209
76.29.180.46
68.62.10.88
99.25.103.58
85.23.163.110
76.28.116.113
76.88.39.102
67.167.158.62
64.126.160.136
93.159.111.73
72.229.186.136
24.113.56.216
70.169.168.7
75.70.235.31
66.93.241.126
190.239.137.87
74.95.102.125
68.15.4.17
24.161.151.192
109.117.166.62
80.1.211.194
62.3.69.96
67.163.232.14
83.228.34.29
84.57.42.160
79.228.199.109
76.95.85.87
24.27.111.220
68.35.183.230
74.128.25.16
41.132.218.162
69.47.168.246
70.60.183.160
78.46.114.50
79.221.55.108
71.199.49.227
68.188.222.216
69.196.132.152
77.73.88.14
128.30.76.111
72.29.2.96
72.177.46.143
66.75.62.162
78.45.21.134
65.15.156.202
75.67.10.16
85.225.123.229
78.72.181.116
66.188.104.22
76.89.88.217
67.163.188.32
178.63.25.2
149.20.54.250
71.22.143.125
78.70.62.206
72.73.80.22
69.142.22.192
75.19.51.139
24.18.135.152
24.107.51.225
46.50.42.155
142.167.7.99
69.139.44.53
62.195.29.254
64.20.13.2
24.67.172.110
78.60.214.94
193.232.112.8
74.116.187.251
84.48.83.141
213.83.125.216
74.32.189.50
78.29.102.102
24.116.177.66
24.80.113.17
69.243.145.164
76.118.15.59
50.35.189.5
128.173.13.104
24.61.85.204
69.134.65.90
59.167.180.218
67.140.221.110
98.228.252.64
85.254.235.30
95.19.151.146
65.96.245.82
76.92.151.164
24.229.47.54
79.163.104.42
24.167.187.48
71.21.205.252
75.80.135.148
76.174.172.62
78.105.16.163
68.183.17.211
24.193.18.233
24.243.166.65
70.170.77.38
66.27.95.229
78.86.130.7
98.71.10.147
70.251.24.211
69.118.81.127
131.94.130.241
24.60.200.153
72.83.138.130
74.212.205.5
77.102.217.44
64.58.181.194
50.47.144.171
76.121.136.96
71.243.249.131
66.27.156.217
82.6.102.50
68.229.187.34
24.95.65.121
68.63.38.7
79.75.222.26
24.141.168.138
71.254.201.77
24.34.152.229
66.188.112.47
71.97.126.114
71.97.126.115
24.21.45.112
77.239.80.121
75.83.189.101
74.90.133.218
76.229.204.192
74.143.59.82
69.141.143.175
78.83.107.225
24.62.170.253
58.109.21.194
75.15.112.249
69.47.162.154
79.173.44.240
60.234.133.53
75.70.24.77
75.120.142.170
77.242.104.226
17.209.8.37
109.75.176.245
94.67.149.63
71.195.227.16
72.196.147.107
81.134.94.13
2.105.66.222
62.90.151.150
71.215.117.4
99.159.29.244
200.86.226.214
74.138.105.207
71.163.157.111
65.102.191.206
74.138.156.229
87.228.117.174
71.228.156.102
74.116.110.21
24.183.40.109
77.64.194.142
66.87.0.192
71.54.73.61
71.67.141.48
24.10.84.112
62.189.158.97
71.97.56.129
66.226.44.188
76.119.40.65
61.14.143.130
75.150.71.35
66.108.117.79
75.57.131.100
108.68.106.144
70.173.251.114
69.165.253.142
76.124.100.99
71.102.252.31
2.96.202.255
83.226.121.71
64.53.60.34
64.229.132.183
69.122.93.13
69.205.180.22
65.36.75.38
89.174.174.202
70.245.29.100
70.176.111.72
66.177.73.191
74.228.182.235
71.12.3.1
84.63.178.84
69.115.180.177
78.35.182.249
68.12.238.200
78.158.110.2
75.150.132.150
77.251.21.17
78.34.167.239
71.67.106.85
66.169.136.74
38.97.97.99
18.85.35.111
24.69.96.222
24.240.79.54
68.224.139.234
71.246.245.176
74.142.2.82
24.210.246.13
74.207.230.180
203.217.22.61
173.23.73.225
4.59.160.2
67.168.131.23
74.178.195.134
98.113.53.7
87.206.13.233
67.180.9.179
64.235.199.49
75.152.106.16
38.96.137.123
70.130.41.169
24.156.90.234
79.186.209.104
89.72.156.23
12.198.33.246
24.110.116.131
68.14.178.79
75.22.188.115
74.185.89.215
50.41.178.238
69.25.110.10
71.42.216.39
66.39.218.46
62.78.205.199
81.152.162.158
64.183.89.42
71.185.219.88
78.130.171.67
190.224.238.50
88.196.182.45
69.127.84.76
74.143.86.210
77.171.128.118
74.182.178.234
75.162.133.151
69.203.20.150
71.37.6.151
71.228.219.168
69.120.160.247
68.47.135.24
74.114.124.9
108.6.246.40
184.145.56.198
68.36.155.120
96.32.131.141
70.62.88.130
65.36.23.27
24.167.191.78
66.162.130.130
24.149.107.177
76.26.34.231
75.97.37.87
24.23.24.168
85.89.168.62
50.46.125.142
68.198.68.115
67.5.146.165
86.41.11.159
68.97.192.119
72.94.35.196
85.140.25.155
46.216.126.57
50.14.209.228
74.69.33.252
77.229.39.38
98.176.97.128
94.193.253.17
70.36.197.133
76.27.252.44
75.71.16.190
65.32.207.247
140.186.70.153
68.4.103.124
80.195.80.206
69.111.191.126
46.246.125.23
84.208.220.203
24.115.80.166
50.16.249.185
79.235.65.136
71.246.119.140
75.48.31.227
75.36.244.239
78.1.147.82
80.27.101.101
24.20.45.229
74.34.119.215
71.182.150.199
24.177.154.240
204.16.202.180
67.183.16.32
109.86.233.249
75.145.118.49
71.114.197.128
75.84.199.70
79.111.49.95
64.241.192.35
70.95.111.30
79.160.67.64
98.143.103.124
24.89.244.219
207.98.210.144
80.216.22.252
81.141.84.71
76.68.105.248
24.232.228.9
91.115.204.140
71.187.63.192
68.1.51.207
92.224.241.95
78.57.149.176
69.196.165.51
77.186.14.140
74.59.81.90
70.126.90.131
24.214.83.87
79.172.111.154
79.112.59.194
24.149.34.14
79.168.123.34
96.25.102.57
68.149.9.1
94.79.133.235
24.37.87.122
82.242.105.40
75.72.2.162
69.88.213.122
69.134.7.126
81.224.199.241
80.68.91.196
71.235.28.217
74.46.224.88
75.128.26.42
76.92.134.78
75.176.185.99
69.245.68.34
64.229.31.220
80.56.118.117
71.199.89.47
68.96.247.94
62.183.64.172
76.118.52.61
64.119.144.107
76.111.169.41
67.84.140.91
65.51.202.22
77.13.164.88
72.95.196.141
24.119.105.59
76.10.214.89
66.254.44.108
71.231.151.9
58.178.206.12
24.246.65.77
72.13.95.15
74.113.42.73
77.215.71.45
75.71.55.54
12.190.193.195
81.108.61.52
130.184.42.169
38.121.35.84
76.247.190.45
70.78.168.172
12.197.84.194
63.167.66.3
71.79.248.208
67.204.8.149
71.67.143.221
65.28.237.67
24.155.176.189
62.201.142.65
62.220.146.204
79.169.64.203
75.141.139.147
67.55.2.89
90.203.40.181
66.58.238.22
50.53.58.67
91.121.91.90
109.107.36.246
24.129.76.44
74.215.9.47
70.114.154.68
46.98.56.85
80.216.252.10
50.53.96.77
64.88.11.89
71.184.172.39
24.247.158.144
66.214.116.79
69.115.94.143
62.198.246.235
207.206.194.10
69.63.164.98
66.44.159.15
83.216.71.218
82.0.21.89
64.81.51.229
82.29.252.18
24.189.107.235
67.190.7.27
69.204.251.106
78.53.125.99
75.137.249.221
46.102.241.109
76.173.155.122
12.201.211.38
72.26.142.149
65.113.33.114
80.168.43.62
69.152.170.52
64.79.143.212
58.169.227.8
71.229.145.232
24.2.243.57
66.245.70.27
94.193.93.27
50.46.126.174
76.93.0.238
63.229.62.199
24.155.230.237
71.37.32.178
87.160.212.224
71.58.90.40
70.185.222.183
2.102.59.35
79.114.16.153
70.189.206.193
12.87.176.154
83.87.119.121
83.172.122.237
80.221.19.52
69.205.202.66
24.109.233.56
24.137.73.230
65.29.113.207
74.70.200.135
24.222.79.230
76.28.75.62
89.79.17.169
71.234.162.134
24.6.228.31
66.75.242.252
67.174.221.115
74.98.223.163
76.26.92.222
69.238.241.77
69.149.218.155
68.190.50.161
79.112.124.70
67.166.158.233
24.21.49.147
76.10.149.84
24.99.47.135
77.24.10.144
68.199.37.238
69.151.254.187
68.202.238.234
68.185.251.199
81.97.92.242
70.177.243.45
83.83.168.185
24.185.9.133
72.19.165.12
69.203.30.171
70.134.211.186
67.82.138.239
24.21.240.100
70.168.67.12
75.106.42.136
71.235.155.79
68.15.61.2
62.97.226.122
64.121.96.97
60.241.14.132
85.165.97.36
72.14.191.28
68.149.147.8
24.100.158.150
24.6.49.210
24.250.131.232
78.145.242.153
81.234.144.213
65.183.133.152
62.21.6.24
80.176.82.125
24.85.178.176
76.235.173.198
69.121.104.58
18.216.1.239
24.4.46.120
76.126.45.134
128.2.97.163
74.85.144.253
67.169.24.203
74.143.249.13
82.130.50.1
75.101.60.110
64.83.197.8
76.1.51.95
41.132.125.244
24.4.174.36
72.135.236.153
67.171.28.164
67.177.126.250
67.169.146.156
24.6.56.7
50.19.74.172
68.37.199.128
24.20.20.112
70.79.75.109
74.114.214.101
69.95.95.111
67.49.221.227
99.246.70.226
98.212.23.250
24.183.46.99
76.115.49.251
24.84.37.113
84.250.80.30
66.90.75.67
81.106.111.231
74.190.145.57
222.155.60.190
24.202.243.206
91.180.227.100
69.250.40.27
75.36.174.41
24.141.249.25
61.115.114.118
75.48.125.33
66.183.59.40
76.183.142.244
90.54.226.98
208.5.208.120
72.252.137.164
70.81.30.131
78.69.139.3
76.27.59.10
79.40.227.53
77.251.186.202
75.181.40.149
74.80.51.161
17.209.11.245
88.96.200.110
81.100.211.9
67.84.207.53
66.158.178.124
67.55.31.162
84.228.243.15
89.100.72.168
204.232.203.169
74.92.140.17
76.10.185.181
72.200.94.245
178.33.214.67
83.149.112.133
24.246.27.68
67.247.88.99
67.70.43.133
24.63.206.22
77.98.145.160
95.22.218.5
85.218.16.10
71.236.194.230
41.15.122.103
24.177.244.148
76.25.156.61
59.92.49.29
67.81.124.174
64.55.111.30
108.66.119.151
46.7.218.234
72.188.179.176
76.226.199.152
71.30.179.3
12.133.142.34
62.5.221.72
69.50.57.138
76.105.223.56
98.235.155.209
46.109.37.55
75.45.126.35
68.149.107.150
65.96.173.60
74.124.97.65
68.82.247.149
69.88.38.223
79.198.128.219
69.177.22.97
76.20.250.161
80.199.31.74
68.162.85.213
65.182.34.114
72.66.202.38
71.63.227.189
82.20.56.214
24.251.217.178
67.180.132.65
69.248.80.56
75.89.204.32
71.213.203.107
79.184.80.212
72.192.100.106
68.103.113.219
74.77.102.160
128.243.253.217
71.34.19.201
78.105.207.247
24.15.178.131
76.90.114.143
83.80.205.18
77.1.84.125
24.21.211.215
71.180.160.10
213.133.98.83
58.175.213.68
69.160.157.129
213.168.203.232
71.56.137.132
76.115.137.4
62.203.98.128
74.192.11.242
62.45.239.220
76.171.40.62
79.166.114.66
71.59.74.183
68.3.2.6
75.69.29.179
70.165.35.18
71.84.160.209
69.27.199.226
70.138.138.49
71.246.224.52
68.188.234.227
66.41.141.213
67.36.26.243
79.46.97.105
71.126.134.20
59.189.104.237
60.242.188.103
78.105.64.25
76.177.159.219
80.101.150.16
75.170.22.175
71.197.119.221
83.227.89.72
68.122.190.235
76.184.96.142
24.143.101.96
71.135.40.193
68.52.113.122
212.149.246.10
18.171.2.28
82.13.22.131
80.219.1.171
67.180.51.243
64.129.165.5
89.141.35.214
24.61.104.245
173.19.43.212
76.120.47.195
77.194.120.20
24.44.13.87
24.218.225.235
76.170.96.54
128.2.136.175
46.105.42.101
71.107.250.98
75.80.35.169
82.25.30.154
99.252.252.189
66.31.126.60
77.98.244.155
91.152.197.45
64.221.10.16
86.122.188.15
190.167.180.97
76.117.186.6
68.174.91.184
74.4.248.34
76.104.157.191
92.119.161.186
67.78.124.195
65.80.7.122
80.223.212.125
74.57.236.239
24.90.236.191
67.188.148.12
74.192.220.68
38.99.32.194
24.254.165.39
68.80.50.106
76.122.5.224
24.128.209.187
69.14.75.188
62.121.74.6
71.175.78.46
69.34.210.147
67.167.199.2
66.60.166.202
18.216.1.243
24.93.188.151
38.99.141.42
78.47.9.107
79.74.80.236
68.66.18.130
74.96.220.82
12.222.208.171
72.24.31.56
66.41.152.245
50.14.231.79
66.45.71.150
74.96.58.199
2.91.158.53
71.232.37.70
75.82.133.244
77.160.90.45
98.186.87.156
76.26.251.28
24.203.45.97
81.155.246.63
65.44.148.210
68.69.242.207
66.166.60.12
68.234.177.1
69.127.66.246
76.20.230.118
80.4.35.5
64.172.15.25
68.84.8.238
70.29.91.156
63.255.173.99
188.235.15.239
78.143.222.59
74.222.243.123
79.182.41.191
82.103.69.162
68.204.114.217
74.109.17.239
70.87.222.74
24.7.158.162
50.53.203.18
67.161.80.27
24.62.184.206
75.109.221.22
72.202.134.75
88.104.27.32
173.165.138.61
83.30.226.208
80.81.35.79
74.76.144.216
72.179.58.118
68.159.116.73
86.205.37.188
24.245.20.205
71.177.147.232
80.183.88.198
69.164.218.197
71.191.248.248
24.20.144.187
71.33.233.182
88.217.141.156
74.243.242.205
70.241.24.196
80.240.211.71
75.4.33.117
81.167.76.49
71.251.52.110
14.202.132.33
66.227.217.36
83.17.127.110
76.202.145.93
41.146.63.230
69.111.104.131
24.237.103.13
24.84.13.213
77.48.156.74
98.235.193.143
70.246.52.197
71.196.151.93
80.177.123.201
71.255.197.250
70.66.33.164
24.5.88.100
66.162.131.226
75.27.61.207
83.45.31.82
188.174.8.126
78.109.182.43
209.15.222.6
69.129.1.218
71.236.192.162
76.102.169.157
69.120.5.218
79.184.73.179
78.128.196.201
72.153.217.253
74.134.32.178
24.22.182.224
79.173.34.229
77.102.232.206
67.161.70.178
146.187.72.41
71.237.141.82
68.51.12.134
24.246.64.4
68.118.13.218
67.166.221.8
69.76.19.231
81.86.166.93
50.56.120.189
24.125.162.37
91.85.220.84
76.226.199.135
46.98.144.173
70.33.254.77
24.40.174.51
76.183.75.35
62.21.178.3
69.181.137.24
62.147.135.211
75.186.58.44
78.241.14.38
50.44.143.223
74.137.57.67
76.166.220.72
68.59.22.5
66.161.170.16
24.138.120.9
67.186.215.161
24.22.130.218
24.108.241.247
68.230.175.7
24.2.66.59
68.105.26.148
24.177.171.188
76.10.136.190
66.142.54.39
41.241.170.97
74.94.122.123
8.8.247.94
78.69.98.86
67.248.6.59
96.48.45.7
41.185.148.222
24.199.122.205
70.29.32.146
38.103.165.36
65.92.5.34
94.171.156.157
72.49.160.54
24.55.90.204
68.144.93.234
75.150.34.209
78.69.3.81
68.41.169.82
75.101.116.11
71.173.96.13
68.58.211.22
65.27.183.69
65.7.143.159
27.100.11.72
2.104.178.70
77.40.74.251
79.71.93.122
74.192.30.213
76.102.112.101
152.3.153.89
38.99.234.201
41.105.52.37
75.87.252.116
74.177.238.46
68.225.253.240
61.24.184.128
79.152.70.111
66.12.62.102
65.94.191.33
71.231.126.115
71.228.157.119
75.151.133.89
66.108.226.57
69.22.23.236
78.105.97.103
68.47.4.242
67.60.153.54
84.111.157.192
81.247.128.37
70.77.59.238
46.11.23.138
68.197.4.128
65.27.98.106
71.72.24.140
98.225.172.187
72.148.105.103
24.59.190.16
64.178.129.122
63.225.138.161
24.214.131.229
80.177.21.53
65.164.153.165
72.14.170.202
209.159.220.104
70.173.51.74
71.136.57.220
80.144.77.17
69.165.138.238
83.134.115.168
86.45.249.64
76.28.171.117
83.93.43.76
76.30.18.107
78.86.127.17
97.67.95.97
70.54.221.203
67.52.151.102
67.52.151.100
65.60.135.187
64.139.230.65
212.25.68.178
68.147.212.225
70.80.191.106
71.137.241.71
70.114.145.186
66.244.74.177
67.160.185.139
72.145.217.214
173.18.249.251
82.210.164.139
24.106.22.62
66.115.235.2
208.69.129.153
76.22.83.89
74.184.165.100
79.160.0.106
41.232.109.220
24.2.172.61
64.145.66.149
89.233.25.90
46.119.79.168
71.248.43.14
83.101.33.129
24.39.1.34
69.140.118.191
66.119.170.66
76.71.58.166
69.11.105.50
78.149.178.3
71.211.52.149
71.204.43.193
68.80.166.130
67.18.187.64
82.161.47.180
78.42.124.164
79.158.205.229
69.134.122.65
75.92.81.135
24.6.16.190
62.30.162.205
67.8.47.122
24.176.226.88
68.7.2.127
92.73.188.116
60.240.27.65
24.191.220.82
24.167.164.86
24.177.214.186
72.130.84.207
76.10.188.251
89.184.130.11
24.67.88.50
89.110.56.135
66.49.38.75
74.115.254.5
87.198.19.107
79.142.232.166
68.239.169.114
79.111.234.82
91.154.56.58
85.219.144.217
64.132.147.139
80.229.187.130
69.150.141.141
24.152.245.216
68.210.118.45
69.251.33.9
72.231.173.87
64.203.114.61
69.47.51.187
109.191.176.95
65.78.142.41
75.67.134.226
62.219.97.96
70.62.140.71
70.178.185.9
24.68.37.145
84.48.228.164
74.196.201.196
80.109.52.43
69.121.49.87
78.144.179.236
64.90.12.82
68.179.62.91
67.210.63.189
70.104.135.109
85.233.106.39
81.243.22.160
12.178.152.2
129.27.218.77
79.97.87.72
46.38.167.95
64.19.65.82
93.103.35.117
83.26.210.53
74.138.244.210
173.255.127.151
80.139.24.157
77.222.133.218
75.121.19.213
80.116.115.173
70.167.155.123
65.40.37.143
71.238.75.139
67.250.50.83
70.176.112.62
68.231.106.81
81.23.56.53
81.234.213.20
58.160.38.190
71.201.20.179
74.215.28.187
69.165.253.243
76.100.166.228
67.184.167.145
74.109.231.179
91.121.182.219
76.27.216.193
24.21.60.0
75.44.144.187
76.17.99.36
78.23.200.84
24.209.148.116
72.208.251.131
82.139.64.190
69.158.50.76
99.236.148.40
24.215.52.66
67.248.130.230
50.15.202.62
2.93.223.165
24.20.195.147
64.208.123.204
80.217.204.82
64.229.194.175
70.126.222.2
71.229.52.125
71.231.126.159
76.94.183.11
80.56.46.174
77.168.44.145
18.111.57.144
75.142.248.248
62.163.86.181
68.110.144.143
68.35.236.214
108.35.28.151
124.169.83.105
69.26.159.99
67.173.6.192
72.177.64.221
24.29.14.54
76.77.75.3
75.22.57.95
75.101.134.40
24.132.116.76
77.253.175.155
66.30.242.229
134.71.134.76
68.38.96.58
41.135.99.154
71.88.111.169
62.195.46.19
67.202.81.235
67.180.129.238
67.163.212.161
68.159.104.10
67.236.141.112
75.92.174.124
98.237.213.89
77.232.137.85
41.174.7.191
69.137.146.27
71.215.45.253
68.11.89.197
68.203.13.20
209.160.46.94
76.85.202.254
69.125.112.232
75.30.85.42
69.253.19.242
24.226.161.104
80.101.0.19
68.42.32.255
77.71.161.115
77.126.75.152
71.166.54.121
12.176.153.26
69.138.33.160
72.192.98.116
67.191.77.142
71.32.88.5
96.250.219.153
69.237.236.93
50.16.219.29
64.61.115.26
75.85.172.65
74.74.227.35
72.193.244.235
71.237.92.144
71.208.218.129
71.224.66.154
68.190.125.8
96.241.67.28
71.233.3.17
12.43.161.87
66.245.199.51
95.26.148.90
76.28.180.118
78.29.119.211
70.57.5.13
64.231.21.81
75.62.71.129
12.236.139.89
78.14.188.181
174.97.174.7
82.132.139.250
68.59.52.65
24.246.41.106
67.85.0.112
81.156.208.28
98.83.128.250
76.122.187.227
68.107.70.225
76.21.114.91
70.182.154.206
24.53.135.248
83.238.233.26
50.18.22.24
70.70.35.222
24.131.81.110
72.193.140.177
86.42.67.191
72.184.3.120
68.36.244.92
66.65.96.165
76.103.205.127
80.57.16.227
70.98.93.211
76.174.152.63
82.43.117.4
94.208.55.62
75.83.95.232
78.83.248.171
24.17.140.100
72.241.224.103
67.253.145.91
70.179.146.206
76.125.214.194
76.112.188.153
68.6.116.150
78.72.246.80
61.172.255.27
66.151.203.10
81.33.126.163
81.148.248.50
174.20.214.156
82.47.5.22
24.49.48.224
71.192.108.31
98.178.190.119
174.60.33.203
87.96.207.15
79.160.4.158
60.242.190.43
67.207.129.133
70.76.103.239
24.23.191.204
80.174.41.68
64.128.164.132
12.130.86.9
74.73.29.226
98.26.21.238
84.57.23.126
71.231.48.132
71.13.74.243
62.90.194.108
46.50.126.158
24.98.165.80
65.112.244.162
76.190.213.155
68.168.168.70
2.202.102.177
94.171.157.7
83.83.60.70
96.55.46.58
71.183.95.247
75.82.130.75
67.185.97.58
24.124.70.141
85.78.247.208
72.215.41.64
75.13.136.158
71.199.117.235
79.119.241.133
46.105.148.218
75.149.104.110
68.225.175.241
95.32.228.141
38.101.126.131
69.241.19.12
68.98.215.195
68.36.189.118
83.143.83.163
76.70.42.25
78.46.108.74
98.219.108.96
24.127.230.192
77.78.85.37
78.106.57.236
80.212.252.115
60.234.139.225
24.23.240.24
69.115.222.172
69.115.109.208
93.42.220.216
24.130.132.104
69.196.171.160
67.191.29.225
68.96.205.135
125.237.159.30
24.12.252.93
76.22.205.79
66.41.112.233
70.137.152.114
65.9.245.216
66.94.35.20
65.96.64.192
68.32.26.30
24.200.122.211
71.252.119.18
60.241.199.15
76.176.195.107
24.3.93.106
71.181.63.164
69.60.75.115
75.152.163.99
67.205.244.124
77.222.128.58
66.245.111.6
24.217.139.233
62.107.165.39
70.161.92.143
24.255.46.151
82.128.221.40
76.14.85.158
41.208.204.104
138.9.58.116
189.135.14.60
67.173.184.98
87.194.120.170
50.46.251.187
24.246.27.200
71.187.194.55
109.90.37.58
78.69.248.63
2.102.33.170
63.126.72.25
76.91.176.195
64.141.48.15
72.47.136.205
24.121.239.49
65.188.180.36
41.135.35.157
68.185.135.6
66.214.200.174
76.125.177.70
50.15.177.170
88.198.52.36
24.252.242.50
83.169.43.140
24.181.115.174
80.216.4.108
46.138.79.154
98.248.73.8
75.69.69.166
76.169.154.144
71.58.179.136
78.86.200.16
86.185.20.66
66.35.36.132
24.4.172.88
76.198.246.142
84.92.108.8
71.254.183.150
76.183.59.250
67.161.189.17
67.83.73.89
50.0.24.217
71.56.180.52
76.199.74.127
78.90.203.190
70.83.212.139
98.111.152.217
70.36.144.113
70.72.52.60
75.84.188.52
76.169.136.14
70.190.8.89
64.247.83.28
79.114.121.73
24.235.219.146
50.0.92.215
75.118.18.52
24.161.126.7
75.84.218.252
80.60.62.8
79.104.4.204
76.219.136.102
24.71.237.7
69.143.26.138
213.213.168.90
75.82.42.153
68.80.3.191
18.243.0.101
79.114.50.27
71.45.52.61
173.79.89.3
96.30.138.250
92.225.139.96
76.122.241.223
74.192.136.119
24.68.77.88
69.161.42.200
64.90.240.50
75.5.239.189
50.81.173.75
24.80.227.245
4.59.151.237
75.72.217.101
82.123.47.234
67.243.52.202
70.170.71.99
62.155.164.14
68.169.156.68
68.34.212.95
74.77.39.41
72.174.200.190
94.195.253.215
75.177.142.160
70.250.198.183
71.229.68.102
80.127.33.42
71.210.119.101
108.17.121.121
76.121.155.143
67.164.208.148
74.207.40.148
75.4.251.182
66.194.18.154
76.216.203.198
72.187.121.95
70.169.87.181
71.113.227.176
69.254.219.62
67.169.230.84
74.92.169.169
64.185.144.48
85.195.47.37
68.84.223.222
65.173.193.67
147.230.74.150
76.122.50.107
67.211.65.231
63.241.125.130
74.70.65.23
75.76.170.25
80.245.178.174
24.246.29.48
140.180.130.15
24.246.29.40
68.185.203.100
24.190.17.244
68.34.219.235
75.225.15.146
70.177.246.167
76.224.126.241
69.166.21.120
24.2.112.116
65.27.127.169
78.148.145.188
24.4.69.228
66.244.106.164
72.229.185.182
94.176.86.110
75.108.226.88
69.167.133.39
81.102.129.158
24.77.145.2
81.164.165.124
70.75.62.123
24.117.101.231
12.46.128.66
67.148.118.130
24.30.98.10
68.0.85.185
78.36.219.181
38.108.146.102
41.193.16.230
129.67.158.197
24.145.30.38
81.164.117.58
24.1.1.149
77.49.95.87
79.97.16.107
90.199.228.62
67.223.17.115
86.89.241.127
71.35.166.180
72.208.184.182
24.239.126.153
69.115.54.55
69.164.196.4
24.87.44.132
24.73.232.230
24.226.119.141
68.89.23.0
74.177.28.68
69.117.229.112
213.171.204.119
72.234.17.117
198.144.209.14
24.250.139.115
84.27.80.204
75.169.204.51
80.48.174.112
24.183.81.42
24.88.121.216
90.218.45.111
70.69.184.11
76.98.161.57
76.16.97.27
184.71.164.254
82.6.105.32
50.53.36.2
68.38.146.93
86.156.132.79
83.6.203.157
68.6.158.60
72.218.43.145
8.24.3.16
24.49.55.53
81.210.206.76
71.236.190.9
98.161.53.236
66.182.232.53
78.37.224.108
68.105.211.63
75.181.99.38
76.126.98.71
76.164.46.166
24.46.47.87
70.79.203.225
24.187.143.68
75.147.190.185
80.203.27.171
70.251.121.138
72.49.219.42
71.35.181.17
76.215.47.132
81.65.160.149
64.112.217.242
66.161.136.211
71.239.82.31
178.137.129.241
71.182.155.24
72.193.231.228
79.169.3.198
75.176.74.10
69.196.186.157
78.8.247.64
66.46.112.60
66.54.212.101
75.131.76.149
92.98.92.35
72.249.144.57
66.213.185.205
24.224.145.44
96.242.55.211
68.116.167.205
67.42.176.61
77.110.10.167
76.202.70.24
76.222.229.209
131.188.30.246
71.6.155.198
99.11.51.29
69.166.20.179
24.36.99.165
72.12.168.239
71.227.153.174
78.73.86.69
66.112.104.91
66.108.19.200
24.5.121.242
74.197.24.162
98.255.132.66
68.118.196.38
77.121.177.69
24.125.27.249
74.231.18.162
69.205.65.57
128.86.145.107
68.197.187.21
64.55.45.194
64.65.227.52
69.40.1.240
71.34.91.105
82.7.144.129
76.23.229.62
24.10.89.9
93.38.34.152
24.23.45.182
80.51.175.219
71.191.174.166
67.98.161.114
24.76.5.16
79.178.9.184
2.26.141.245
68.193.1.182
68.193.8.60
24.199.21.78
81.56.111.242
70.132.171.198
24.161.74.155
76.104.134.220
71.66.100.246
74.137.110.24
190.238.215.152
81.29.17.139
89.234.117.111
74.72.249.5
24.45.196.178
79.131.167.93
66.189.36.203
66.188.98.98
78.52.233.128
12.239.78.226
67.172.213.172
79.181.204.121
71.94.77.133
79.169.4.25
71.183.82.183
70.146.254.171
80.98.24.21
99.109.150.50
69.140.150.131
79.135.115.242
71.204.103.57
99.252.42.65
68.57.175.104
76.185.32.144
76.88.152.13
64.185.141.131
66.61.68.6
24.191.197.189
46.159.41.2
66.45.248.13
74.255.63.136
76.21.19.28
68.196.64.191
24.84.112.2
71.87.191.73
70.241.19.48
207.62.238.151
58.174.28.144
66.150.171.4
67.239.1.173
96.228.33.25
24.117.32.92
24.89.69.231
68.63.44.48
65.95.207.225
69.209.49.137
24.196.228.218
77.162.0.70
72.38.214.192
75.109.47.18
76.20.218.41
74.96.253.192
82.8.29.248
46.0.1.230
24.128.110.122
24.128.182.77
76.123.42.117
95.149.172.67
24.32.207.197
68.185.25.82
70.240.210.227
77.181.224.204
75.110.33.216
68.196.215.204
71.153.138.72
74.112.81.204
41.5.155.7
71.84.9.45
81.190.220.83
41.241.51.248
78.105.123.202
81.82.52.140
98.237.105.64
75.152.34.4
24.6.240.210
99.100.54.15
65.126.112.212
24.141.7.240
75.70.16.213
77.102.237.210
70.232.36.230
71.238.196.14
66.146.40.19
68.226.55.110
66.56.9.250
96.255.138.111
46.242.54.151
24.152.145.110
24.118.211.47
76.10.184.131
76.117.232.56
70.31.37.86
88.75.64.125
62.30.78.123
72.209.150.228
89.232.126.147
70.76.47.214
123.255.40.229
66.244.255.10
24.215.64.174
72.193.151.153
67.188.138.190
41.131.129.171
67.169.54.41
71.45.29.180
80.168.198.38
46.48.162.28
67.111.52.66
69.125.210.179
71.85.4.233
75.76.65.16
63.202.48.98
38.108.143.12
76.242.156.156
79.229.126.139
74.13.151.147
50.53.187.56
67.168.164.133
74.128.230.229
76.111.37.50
93.87.203.232
72.200.175.53
50.16.197.252
70.124.90.149
78.182.71.30
62.220.137.130
71.125.251.222
67.84.142.111
12.159.175.242
77.65.41.243
98.239.145.157
70.54.11.90
99.147.245.18
65.118.253.132
72.129.50.192
69.165.244.98
74.94.238.161
69.74.54.2
76.126.115.186
68.3.198.12
74.98.45.179
76.106.4.169
74.204.71.133
77.189.62.67
75.108.166.153
201.173.114.104
76.124.4.77
71.91.77.11
24.77.143.121
62.75.224.49
24.128.51.22
49.50.247.77
72.39.159.48
24.192.102.113
72.39.219.17
24.130.140.203
67.55.25.50
71.228.207.135
86.178.191.6
184.106.170.220
24.113.166.120
82.196.122.188
93.96.115.242
70.114.196.216
74.177.99.229
76.202.117.28
68.48.203.170
75.148.50.1
68.189.32.87
98.240.169.117
69.164.222.144
71.89.81.90
75.30.97.142
85.17.27.92
77.177.169.199
76.168.193.80
24.183.25.189
74.45.200.226
77.168.186.159
69.70.237.182
62.28.5.100
71.232.24.67
69.56.173.164
41.72.140.140
130.88.161.143
70.27.30.174
68.191.46.245
69.47.147.69
82.148.199.2
84.197.202.39
72.64.81.232
41.177.242.156
74.74.175.119
66.230.117.164
67.8.39.84
79.179.32.18
66.26.229.147
69.164.215.45
74.83.50.50
67.168.81.142
71.82.139.62
24.196.238.122
76.30.232.158
79.111.33.77
89.79.157.116
71.90.79.81
67.173.101.246
62.87.174.54
64.85.163.77
38.105.226.34
76.73.173.3
79.18.65.102
50.36.82.255
63.231.17.126
98.100.216.98
69.137.148.149
78.90.106.57
79.191.199.92
71.218.222.56
75.71.34.237
77.22.169.75
71.115.62.115
69.18.27.124
68.0.173.181
24.73.33.142
50.72.223.54
74.8.36.5
71.36.109.181
71.202.101.55
72.214.6.2
2.1.141.232
75.101.196.145
83.169.2.213
50.39.97.63
99.254.127.31
71.179.111.81
71.168.91.115
76.169.140.91
66.169.199.160
80.219.153.85
75.73.5.81
75.137.43.126
80.197.70.181
66.197.134.218
24.22.92.50
67.169.211.35
74.13.111.180
71.180.89.214
71.236.209.142
71.38.184.208
77.255.103.161
71.191.145.207
80.168.247.226
75.17.89.30
24.239.73.36
24.84.218.131
81.108.156.227
71.202.136.142
64.57.240.231
123.255.47.36
67.175.230.21
67.203.115.250
72.43.39.82
66.229.50.150
64.134.67.142
70.114.167.210
67.11.186.98
70.246.138.208
70.180.216.127
74.100.228.84
69.203.21.71
81.190.214.236
71.202.42.61
64.69.112.154
68.71.72.129
69.127.162.145
71.35.176.243
74.83.48.243
24.253.235.179
84.239.133.120
69.142.26.186
84.24.36.128
65.205.116.55
50.129.45.230
68.82.77.88
68.149.138.123
74.12.183.67
68.209.135.62
70.36.138.19
68.222.233.90
75.142.84.40
67.174.224.210
12.91.6.234
70.228.106.32
67.88.223.18
75.121.127.96
75.160.62.193
71.175.77.13
24.140.30.187
66.66.81.207
72.240.29.27
81.210.43.116
66.158.176.226
67.23.32.33
50.43.16.17
76.168.166.55
66.161.225.130
24.63.252.213
83.163.219.98
70.119.157.230
46.4.99.204
97.82.38.148
92.224.98.15
64.184.16.132
67.185.163.12
84.146.55.183
84.149.101.24
68.122.7.234
2.98.214.169
2.119.143.185
81.25.53.119
2.81.180.208
81.102.246.84
4.26.37.34
86.158.206.65
71.77.209.233
12.19.148.101
71.170.14.185
66.44.119.54
67.186.132.109
69.113.219.183
97.80.112.82
69.207.95.53
75.183.171.83
98.215.136.245
85.41.106.11
173.224.125.222
66.66.133.210
24.1.175.104
71.172.241.14
71.205.0.171
63.108.131.149
72.179.57.191
2.80.10.211
66.108.119.92
91.43.97.190
76.124.137.79
75.111.48.188
72.179.37.219
70.190.167.250
50.56.84.158
61.238.250.226
64.223.163.192
156.56.18.162
69.164.221.33
24.215.209.88
76.90.142.171
66.143.210.250
24.82.148.30
80.202.25.38
72.243.211.214
72.234.173.102
74.130.16.196
67.187.115.13
2.60.127.243
71.65.208.20
62.83.51.59
41.145.233.204
70.124.65.183
76.4.70.194
71.65.101.198
65.36.4.10
76.172.105.98
64.110.192.41
77.70.87.47
61.72.139.227
75.79.143.178
70.122.89.10
81.234.195.219
24.246.46.162
24.68.49.75
68.69.141.241
77.255.102.174
80.252.17.71
12.174.118.181
24.14.54.146
69.69.250.90
75.157.167.251
68.48.54.86
18.42.3.252
75.65.125.87
67.175.254.175
68.96.70.93
69.254.117.17
74.95.68.46
65.28.236.96
98.209.175.66
24.61.97.78
65.37.15.177
67.239.76.109
68.116.4.125
78.143.139.12
65.190.15.53
69.195.54.70
79.125.79.39
70.180.223.217
24.151.55.72
99.31.116.174
77.22.24.50
75.103.3.42
64.119.81.130
78.142.45.23
75.158.227.176
65.198.151.241
68.109.24.212
72.177.179.41
46.12.201.161
71.34.2.40
64.120.173.12
24.147.177.247
74.78.71.29
38.121.237.35
38.121.237.34
66.188.105.108
69.115.137.77
68.83.9.76
173.75.42.71
98.206.39.141
24.186.183.122
71.204.172.254
24.118.121.205
76.218.92.172
70.88.191.129
65.198.38.3
70.49.95.141
70.178.189.213
72.135.112.149
24.85.237.44
2.49.66.70
76.119.88.197
68.11.59.178
67.163.73.237
71.175.46.190
64.81.240.184
74.94.156.210
81.155.254.180
69.179.151.228
69.107.104.22
24.18.123.67
71.57.26.37
129.93.94.153
74.68.127.148
76.191.151.44
70.177.121.193
65.32.74.14
78.105.105.80
77.45.113.191
78.22.164.57
84.172.187.128
64.247.128.13
78.8.136.28
76.240.78.145
77.32.14.71
71.203.158.103
69.129.88.146
78.14.38.151
62.31.215.37
66.250.192.130
71.201.101.0
132.177.69.128
90.184.122.91
71.20.51.127
71.22.230.108
63.230.140.42
66.203.142.235
78.69.54.231
71.202.151.162
71.163.125.245
76.212.195.102
24.192.220.167
72.233.188.65
72.87.217.76
62.121.96.36
58.96.72.55
12.49.139.146
80.237.93.75
75.54.86.248
178.151.241.246
84.73.102.36
46.45.6.74
81.235.188.116
67.51.206.82
67.36.25.220
24.78.40.188
79.23.72.92
66.65.235.108
76.242.74.66
77.210.45.238
79.160.51.87
71.89.86.205
74.248.216.114
72.14.177.92
24.213.235.242
68.83.145.121
76.120.71.166
60.242.81.39
74.180.109.149
174.51.86.148
68.16.252.153
158.143.58.34
98.200.82.112
46.4.202.13
69.171.153.99
66.33.206.8
24.222.45.50
74.237.56.254
68.15.155.248
68.81.225.191
68.35.150.170
98.193.147.105
62.107.208.61
68.15.89.108
24.222.163.132
68.37.151.239
24.206.78.189
76.14.232.131
67.187.112.55
67.201.216.185
72.214.16.43
76.105.168.158
50.12.196.39
70.170.110.87
75.85.144.85
68.170.93.84
71.236.174.214
76.87.17.161
66.87.4.130
60.234.30.190
68.56.208.115
72.131.122.22
201.96.199.93
75.144.228.222
24.246.71.56
58.179.153.163
68.169.147.119
82.224.187.53
68.10.113.187
67.255.18.92
76.99.50.248
64.71.211.21
93.108.177.50
64.126.175.6
67.54.225.23
72.28.209.67
109.76.5.19
75.176.108.37
173.14.185.62
69.246.218.185
71.192.32.135
69.172.145.66
78.129.175.184
83.12.95.133
75.185.202.207
65.7.149.90
109.242.129.64
67.6.33.61
83.238.175.109
203.0.139.241
24.222.116.250
212.139.255.110
24.143.242.65
76.200.194.228
80.5.77.117
24.168.33.209
76.120.44.53
98.116.61.187
12.183.66.179
76.103.27.104
63.246.254.12
64.187.64.30
62.72.238.199
68.234.0.126
81.97.59.59
79.114.224.146
71.237.226.107
64.125.235.2
24.130.53.234
24.166.187.45
71.59.132.112
24.4.7.2
67.188.84.239
80.48.104.18
67.53.253.162
67.86.11.120
81.15.131.9
69.30.72.55
74.68.115.87
63.173.8.51
74.109.23.43
173.10.115.182
24.60.82.5
74.88.115.32
72.14.229.81
89.136.136.4
46.19.33.55
79.143.241.233
79.10.235.72
71.193.196.236
70.104.193.168
71.1.77.115
76.14.136.160
66.94.32.70
75.79.182.126
78.192.148.81
67.247.83.62
89.112.9.15
84.2.117.146
66.153.28.52
67.183.195.133
77.120.137.250
75.221.60.139
24.60.85.3
24.154.225.133
50.44.28.49
69.67.167.66
75.109.130.166
69.119.153.225
74.115.237.155
97.123.151.197
72.179.0.141
18.189.7.246
64.91.71.35
174.109.195.95
71.3.24.145
38.105.135.20
24.10.21.204
74.76.100.47
78.33.169.206
70.44.6.41
70.112.157.170
71.20.177.34
66.188.166.95
62.195.53.192
76.250.133.183
77.99.45.247
82.7.252.240
213.129.230.10
174.28.147.86
71.57.69.54
2.126.119.178
84.10.155.138
12.5.54.34
77.70.93.28
76.109.234.213
87.205.64.130
69.231.192.27
69.165.138.177
68.209.125.150
68.50.39.218
72.36.91.162
72.36.91.166
71.131.7.32
77.46.178.138
70.52.172.194
80.56.136.81
66.91.11.92
69.207.146.167
79.52.176.161
24.76.175.6
76.227.235.185
24.5.251.104
46.100.165.231
74.193.191.117
46.4.13.200
41.177.54.119
24.21.45.2
69.14.108.34
67.171.181.188
66.214.141.108
68.186.195.54
65.123.181.5
67.184.112.75
79.36.47.84
72.174.0.162
81.96.191.44
24.144.78.182
81.100.175.89
2.122.220.197
71.33.232.35
62.205.144.163
66.172.221.81
71.141.232.241
24.18.194.13
128.123.242.201
62.195.107.106
75.73.80.251
69.208.84.236
24.215.154.30
67.164.37.225
76.185.59.179
81.153.158.206
77.56.65.249
24.16.200.209
66.31.119.154
74.1.240.59
71.59.105.102
79.103.164.118
82.31.236.204
70.113.28.39
69.140.109.145
69.253.41.54
79.179.40.32
81.82.127.223
78.47.46.34
24.250.226.101
24.0.217.10
91.115.219.193
72.192.197.219
80.212.48.143
98.182.38.178
24.126.186.43
2.96.88.184
70.45.16.113
24.7.201.25
68.40.48.239
75.67.29.201
58.110.27.78
77.23.105.109
69.166.20.23
69.11.234.111
24.137.73.1
75.131.203.186
75.177.18.171
65.183.140.110
92.196.33.250
70.40.189.222
95.153.162.28
86.5.132.105
85.77.47.17
63.131.205.135
71.116.21.67
24.144.55.135
67.3.143.211
216.30.186.226
66.233.229.27
212.204.57.18
74.255.63.158
24.67.79.209
79.97.153.69
96.228.253.85
68.53.131.11
77.249.203.66
94.112.247.107
71.163.69.179
70.177.75.152
78.35.174.75
68.148.227.99
188.40.121.82
76.102.154.3
173.71.39.237
67.205.39.89
81.84.121.197
78.106.132.2
76.236.213.199
81.67.214.172
65.95.8.68
72.187.119.20
82.28.83.33
77.251.235.30
79.186.205.12
79.161.100.157
76.17.127.172
71.122.115.149
38.101.255.135
66.115.128.226
88.67.74.250
79.90.171.102
80.202.169.45
24.181.194.30
75.135.27.123
24.231.189.138
81.168.162.148
24.197.204.90
71.82.73.136
71.59.232.136
76.22.56.212
83.29.100.83
68.230.72.199
77.100.111.26
18.181.3.171
71.252.144.90
77.251.255.109
71.74.235.19
67.167.200.42
70.67.24.4
74.143.192.6
74.207.227.222
24.200.197.48
75.151.163.9
67.164.196.163
24.246.25.230
95.49.26.75
74.4.103.203
62.57.103.122
24.12.186.184
66.197.153.199
62.111.185.68
69.169.134.174
76.171.21.37
64.125.152.130
2.98.163.175
91.205.83.138
81.97.58.209
62.21.126.13
24.251.232.171
60.241.55.122
62.236.60.8
68.5.108.19
70.191.120.10
75.30.122.19
95.221.78.108
76.69.171.225
68.192.5.175
66.147.52.86
75.82.44.119
76.188.180.222
70.239.90.209
68.4.39.109
74.207.232.33
24.165.4.159
72.198.200.177
58.28.153.194
46.0.1.29
62.178.70.49
68.80.242.25
66.27.202.39
76.115.74.224
68.151.241.108
71.233.147.166
68.32.109.156
62.248.137.159
82.35.83.56
81.108.131.148
72.209.185.118
88.115.217.176
60.242.24.133
69.128.103.66
68.38.95.108
69.180.5.17
122.103.238.28
12.96.136.2
87.228.10.87
192.83.228.119
71.22.106.179
91.215.63.58
75.107.148.147
63.249.119.15
84.114.155.197
71.94.132.241
72.196.239.134
76.103.147.145
46.63.46.3
99.175.94.132
69.9.61.233
71.206.191.222
24.126.225.26
66.87.0.105
80.203.100.102
80.57.54.148
71.122.122.177
77.57.180.47
81.187.117.18
69.141.150.39
67.207.38.152
81.187.117.12
81.187.117.11
81.187.117.16
81.187.117.15
72.152.36.66
50.129.99.231
69.172.229.238
24.251.78.136
95.134.229.183
60.242.39.39
76.252.44.96
74.89.152.114
67.162.132.153
66.183.104.177
18.208.0.153
69.18.50.85
79.202.105.118
81.235.10.66
74.109.210.139
71.123.189.90
70.232.49.185
70.165.46.50
77.234.142.92
81.151.227.213
198.252.153.45
67.81.107.52
68.144.23.245
76.226.65.225
75.85.86.29
209.121.111.13
78.96.215.83
99.185.43.44
72.77.85.191
66.90.165.85
46.118.69.144
65.13.60.219
24.180.7.222
67.176.86.181
79.69.239.245
74.37.45.155
69.181.167.32
24.53.76.211
76.64.124.186
67.186.98.42
76.28.194.118
71.227.161.197
24.13.1.153
85.82.255.209
109.74.201.20
67.21.193.37
69.64.32.11
69.81.76.248
24.250.21.242
76.116.64.44
68.11.144.22
70.170.31.104
95.26.174.48
71.94.185.198
79.77.106.72
67.180.177.38
76.250.64.143
71.96.212.164
75.141.219.48
66.148.120.160
74.76.237.67
82.3.255.25
78.171.77.235
76.230.52.49
75.68.6.29
71.156.89.151
41.174.14.16
75.58.123.150
71.10.63.95
62.194.33.195
72.94.249.35
125.236.234.103
94.237.71.249
66.41.235.158
41.81.249.203
72.54.253.242
80.89.40.68
69.234.192.187
74.57.21.94
65.32.48.162
94.246.7.98
12.180.136.130
41.242.240.111
68.12.162.168
67.190.100.88
68.46.89.156
68.115.66.14
24.165.1.69
87.194.24.89
46.208.83.227
24.2.199.30
82.225.89.118
24.239.105.36
75.63.85.178
122.58.138.117
68.96.206.107
67.64.118.62
28.243.248.162
77.113.86.1
24.213.149.2
67.187.212.43
71.37.42.183
69.247.177.155
78.50.53.233
69.127.130.168
46.56.22.52
24.192.181.5
68.228.87.178
68.14.228.19
79.165.176.227
76.171.230.115
87.194.35.218
78.150.237.115
80.63.79.62
24.173.34.242
72.43.201.2
65.60.111.34
87.196.155.74
74.73.0.91
24.126.30.135
68.38.139.88
75.92.65.252
80.187.102.114
64.134.184.79
98.182.20.35
69.198.16.190
75.18.165.21
24.224.233.167
74.68.125.95
67.170.10.60
68.97.119.21
67.2.40.209
66.65.63.112
75.227.57.234
66.68.165.135
66.222.129.122
24.205.139.132
24.0.190.96
67.201.194.243
72.223.43.14
24.179.52.224
62.118.88.11
68.32.204.164
71.2.85.20
66.9.24.5
68.2.179.144
68.102.179.230
173.255.127.48
70.173.133.89
87.194.129.10
74.67.210.148
71.42.216.179
70.132.159.156
194.42.131.86
99.106.171.93
75.37.6.175
68.40.0.144
70.60.178.142
70.64.8.153
81.219.205.135
77.114.142.212
70.71.2.147
24.49.202.62
74.115.237.154
71.229.197.99
67.170.107.118
82.15.8.216
64.147.222.120
75.149.172.33
67.193.30.96
46.188.7.32
71.66.126.153
71.169.14.5
50.17.253.115
64.62.205.209
76.10.184.200
85.157.4.208
75.61.100.86
174.77.35.166
77.2.200.243
64.181.66.146
95.165.67.10
76.175.226.252
63.229.114.89
66.157.164.152
83.149.3.12
76.79.18.74
67.187.136.62
72.189.102.106
76.241.111.150
66.90.156.111
78.47.86.43
67.180.201.109
72.184.220.120
76.89.180.14
64.5.53.244
58.169.205.188
69.176.52.7
109.75.176.49
69.143.176.234
69.91.94.124
109.126.36.127
76.166.145.218
65.121.67.10
78.86.80.173
70.35.43.58
50.43.101.130
76.99.32.40
77.38.153.169
75.111.26.26
72.208.184.120
98.236.150.131
70.91.178.186
74.102.115.77
75.18.48.227
69.2.98.191
69.196.72.190
78.88.48.225
76.31.14.67
24.123.226.159
74.175.159.14
74.131.97.140
24.128.55.232
71.92.251.209
69.109.121.192
80.213.187.123
217.210.248.88
24.12.62.174
83.105.60.177
74.64.16.139
63.126.183.106
75.118.213.0
67.21.96.112
87.194.33.247
75.48.213.146
24.79.93.201
27.32.218.156
74.87.146.62
95.133.3.123
68.224.246.64
77.99.160.156
66.135.41.160
83.23.75.69
84.17.12.94
80.216.249.203
24.197.159.207
67.61.189.60
84.120.151.48
76.111.108.35
77.64.34.178
77.255.20.186
80.193.199.142
50.55.0.85
77.40.224.102
2.122.215.163
72.213.204.172
76.16.180.20
65.118.138.127
72.49.88.3
76.119.57.177
78.86.191.109
24.166.210.143
66.43.16.199
94.171.21.170
76.69.1.75
72.179.150.189
77.185.68.239
78.99.60.8
67.189.132.145
65.183.137.239
66.0.11.234
66.36.130.19
81.207.100.183
74.63.84.36
75.142.106.95
67.87.80.219
83.109.18.183
71.231.194.188
74.221.200.177
66.195.30.142
64.166.166.35
84.30.15.203
86.2.14.116
74.192.33.112
71.56.105.46
79.97.147.170
64.121.165.115
76.28.158.176
80.6.155.36
79.241.110.70
80.212.255.75
46.53.23.166
115.64.192.78
76.217.217.82
24.115.205.99
78.157.72.152
90.153.121.3
24.80.164.160
68.225.239.242
71.172.34.13
68.146.154.220
72.160.43.164
217.137.143.110
66.98.58.96
81.187.202.116
63.193.114.138
18.216.1.174
75.71.128.3
67.10.190.136
66.27.69.142
64.234.246.76
72.129.253.11
72.218.205.196
95.220.245.240
78.73.80.121
178.124.87.29
76.23.15.151
64.135.220.86
24.83.175.218
67.189.92.16
67.188.226.55
82.37.134.116
178.158.80.213
71.50.211.159
70.231.224.248
75.121.152.54
79.185.59.137
75.86.240.173
46.109.35.23
24.158.15.106
70.57.38.65
76.246.40.195
41.185.106.123
72.2.137.170
67.86.113.79
99.144.166.64
24.115.82.119
24.237.81.186
70.64.163.144
79.136.98.41
74.203.159.3
24.20.181.16
108.16.101.187
24.61.136.135
80.221.53.184
75.149.46.134
76.255.213.102
80.254.75.5
74.103.42.235
81.205.150.64
79.184.35.158
67.44.138.247
71.174.126.111
64.115.154.138
85.181.65.129
77.75.167.214
24.85.50.75
68.83.144.234
12.21.189.50
64.178.115.247
58.38.12.121
76.79.4.202
74.7.63.73
70.61.49.39
46.162.14.4
75.26.185.100
83.251.218.142
75.155.132.110
12.46.184.20
71.232.246.19
89.101.248.164
188.195.148.56
68.153.192.83
82.35.105.191
63.234.13.2
77.255.134.229
24.22.200.100
64.91.54.219
76.212.179.204
58.96.52.72
68.122.33.250
173.160.183.185
70.67.27.167
80.212.14.60
67.170.142.140
69.118.123.90
173.242.112.53
81.97.4.9
66.236.78.157
70.124.192.221
24.166.93.243
59.101.14.172
69.172.67.201
59.167.168.105
12.108.130.226
75.158.131.108
24.120.144.34
96.23.146.145
82.199.197.117
69.161.83.193
67.58.213.13
12.49.230.130
72.229.239.254
173.63.35.18
24.246.14.148
77.210.148.136
74.192.12.112
72.28.155.95
24.9.60.87
84.249.106.147
68.46.77.195
81.140.113.123
77.187.17.182
78.92.206.98
76.22.58.46
24.229.197.121
74.109.213.73
68.41.181.86
80.90.168.153
81.187.27.23
66.212.196.3
69.88.215.56
84.212.60.38
71.66.98.247
67.193.202.77
71.58.112.47
74.198.16.30
67.251.71.228
74.202.210.130
71.180.74.168
92.77.140.179
76.126.80.110
38.106.231.2
46.11.10.29
72.72.131.141
2.126.5.187
2.37.161.212
83.27.237.199
24.23.166.95
46.10.39.195
74.240.64.214
68.213.1.122
93.96.117.246
75.150.77.97
128.173.51.34
74.59.133.119
65.92.4.42
69.164.196.24
69.34.199.9
72.93.241.217
66.114.33.52
67.242.8.155
71.94.185.21
69.246.248.42
2.54.138.64
75.224.166.146
69.47.172.141
82.42.232.171
94.254.32.107
84.55.4.36
24.182.67.94
69.157.226.133
99.127.44.240
69.14.30.216
67.58.230.171
72.74.113.46
24.84.48.170
67.176.26.41
82.17.113.248
62.117.0.6
70.55.137.48
24.63.89.202
69.138.77.79
70.113.27.12
27.32.7.61
70.78.197.202
71.37.5.152
68.62.250.38
65.75.251.71
79.33.105.42
65.39.13.128
24.154.223.28
65.102.191.161
64.136.114.3
75.128.2.219
69.112.52.140
76.109.91.79
132.181.14.57
67.160.177.132
65.12.11.208
50.37.43.230
78.145.160.43
82.131.56.2
68.44.115.162
65.93.165.233
86.174.27.200
62.202.66.16
193.11.160.85
71.236.49.135
76.16.252.251
79.186.96.188
69.1.53.40
67.82.96.109
72.92.131.39
50.11.129.12
80.4.21.93
77.66.3.165
76.182.74.143
75.171.171.73
130.184.42.15
95.215.20.7
84.120.99.64
74.207.225.79
147.251.210.189
24.131.74.249
76.113.113.246
75.30.237.76
68.146.83.22
24.130.70.112
24.93.233.25
24.20.59.228
77.98.126.57
74.138.112.31
82.1.33.241
46.59.8.50
70.167.86.76
77.88.107.130
67.8.103.18
70.190.25.45
69.22.239.121
93.178.64.222
24.220.224.83
75.91.17.243
70.90.184.216
98.229.29.193
81.16.127.44
24.224.226.125
12.169.97.130
41.133.95.194
76.184.240.50
81.86.154.168
68.173.140.57
70.174.168.98
88.193.80.182
70.54.69.209
72.223.92.76
69.133.2.117
174.116.132.241
76.67.134.22
58.160.59.80
80.220.216.198
70.250.250.204
99.156.221.96
74.96.69.228
12.170.248.36
62.31.70.85
72.187.66.237
78.102.19.2
76.104.99.252
94.145.65.244
74.177.56.41
67.52.233.241
82.136.252.169
69.130.166.133
2.126.223.146
66.186.163.166
72.129.88.14
97.118.246.141
71.234.169.166
68.5.229.129
66.31.122.8
173.10.47.1
74.40.214.49
65.24.187.163
75.142.223.65
64.60.15.10
72.199.226.149
60.242.243.41
82.10.111.228
70.230.147.110
71.58.152.147
72.23.157.215
74.130.181.147
71.225.67.203
76.27.79.30
63.235.17.164
69.179.227.141
71.198.220.203
90.145.71.154
80.221.41.6
68.102.175.66
87.119.174.3
82.1.117.62
69.172.229.136
67.180.198.185
64.9.237.145
72.200.113.134
66.170.138.8
78.153.90.205
58.96.47.35
24.10.186.255
12.116.10.70
184.1.16.121
70.188.175.89
84.255.204.144
75.162.32.201
75.25.122.133
76.176.189.171
67.215.250.138
79.156.244.44
75.146.103.73
174.129.208.47
83.183.61.101
74.237.68.27
71.181.166.156
67.40.210.26
71.83.117.1
24.106.107.50
18.111.66.36
67.71.56.240
70.63.202.199
68.52.30.192
62.107.80.92
66.84.219.66
81.218.180.39
74.14.126.135
67.85.191.130
63.147.60.252
88.114.121.133
69.209.118.12
199.246.40.54
109.246.240.200
85.157.7.119
68.40.84.128
64.60.55.90
76.27.122.239
74.100.27.39
75.111.160.56
76.93.93.238
18.215.1.101
72.38.164.227
85.229.248.229
94.218.254.135
68.196.124.56
75.141.227.21
24.148.129.204
68.10.213.99
71.38.234.142
68.202.190.101
46.73.49.38
74.90.120.57
62.30.205.12
84.250.72.200
74.63.42.90
38.102.195.50
78.52.143.12
71.62.224.75
71.127.147.67
72.34.190.251
24.21.69.123
69.235.93.96
77.111.157.66
66.130.231.199
74.110.59.14
74.4.74.250
79.43.217.139
66.211.107.149
85.211.64.226
79.136.17.157
66.41.72.151
64.46.21.179
190.213.209.195
46.10.99.193
87.194.138.7
60.241.97.35
68.39.112.113
76.171.50.227
80.168.29.18
67.190.96.199
79.252.152.83
24.177.195.102
63.234.221.66
70.96.26.226
24.130.250.54
72.242.90.25
77.253.107.202
76.187.120.232
174.142.61.71
71.3.147.164
96.50.2.67
74.97.90.102
71.22.224.200
74.177.233.192
174.93.85.183
24.205.247.6
75.69.205.203
173.74.38.24
74.131.253.227
71.33.11.33
92.27.78.165
76.2.219.71
77.49.211.46
64.94.230.190
58.8.88.73
24.115.41.182
71.192.98.188
78.12.75.125
76.115.27.129
69.26.150.26
68.91.83.247
99.120.156.7
69.7.202.2
76.188.99.219
74.195.72.249
69.63.51.248
12.182.251.194
67.175.230.127
108.16.200.251
80.229.123.63
71.76.34.112
71.91.220.179
58.140.20.109
109.77.213.56
74.131.99.83
76.65.200.163
71.35.28.132
24.84.224.67
24.117.217.27
68.68.16.43
66.69.218.85
71.178.207.88
24.63.35.214
72.240.66.25
71.194.153.188
24.2.12.155
38.100.219.219
24.152.226.205
67.158.226.202
64.234.140.136
67.82.125.142
2.88.140.51
2.137.105.208
89.148.252.114
81.175.204.128
93.93.170.123
24.17.124.151
24.162.207.118
74.215.2.155
71.192.116.220
188.26.216.35
24.218.226.91
77.252.162.66
79.191.217.8
86.19.228.17
24.96.192.176
63.230.171.149
76.126.11.28
72.191.54.84
62.20.26.133
67.160.100.187
68.1.137.73
74.96.20.90
71.182.191.132
96.21.201.247
77.237.3.44
74.255.33.139
64.130.192.128
68.47.37.86
75.152.104.141
12.54.189.66
24.21.233.125
76.111.43.122
79.125.35.80
64.42.234.82
62.16.217.133
78.128.29.10
46.128.188.184
71.180.199.161
68.174.70.244
72.185.177.113
75.128.67.168
70.69.225.14
75.141.215.96
68.105.133.158
63.227.167.90
69.164.222.89
78.101.228.96
71.63.187.74
72.193.152.236
78.72.150.157
70.89.191.217
67.43.165.100
74.73.100.26
71.145.166.92
65.95.131.227
2.105.57.226
68.38.145.211
74.121.38.168
69.254.150.27
75.1.104.117
76.185.164.167
84.124.106.157
80.71.135.84
81.63.98.44
24.222.138.73
98.193.78.110
85.210.151.37
67.49.175.173
81.70.173.149
71.207.166.29
24.33.237.210
66.244.223.234
78.86.161.142
142.162.64.221
79.215.80.48
50.53.64.102
108.14.255.49
77.254.187.27
70.53.132.205
24.239.116.114
70.89.112.6
94.175.105.228
80.167.218.241
71.198.44.222
69.56.37.43
69.17.20.72
66.184.63.162
71.13.101.211
84.46.53.122
71.7.183.34
76.28.189.143
24.162.223.201
79.179.15.30
68.61.152.20
74.65.173.160
77.197.50.112
76.91.248.171
78.192.172.66
81.184.0.91
74.41.217.110
67.49.12.58
65.43.175.176
66.27.103.81
68.145.223.177
70.74.225.182
65.104.118.106
195.0.168.164
69.61.217.233
68.16.177.3
85.127.248.252
79.70.68.184
71.32.215.220
74.209.6.207
71.227.133.237
94.66.66.27
216.128.107.65
67.149.77.228
80.56.144.99
58.182.6.208
76.184.150.149
68.169.98.10
75.144.70.37
82.103.238.252
12.32.45.18
62.235.132.209
67.8.212.52
79.107.144.121
24.235.195.170
65.9.31.10
74.217.86.15
76.218.201.134
66.227.149.204
68.193.83.188
71.162.39.136
76.123.56.36
68.196.113.210
71.226.181.223
64.9.130.159
76.214.49.214
68.103.205.254
24.23.237.251
92.81.158.61
46.33.96.5
76.15.192.219
78.70.39.228
67.197.211.176
64.21.241.134
24.165.190.116
69.70.167.162
98.229.223.225
78.80.62.207
68.226.203.78
58.8.238.149
109.157.101.123
68.38.125.115
63.252.117.158
67.218.90.4
76.111.248.82
75.33.39.206
67.11.18.212
67.141.168.170
72.177.35.119
24.218.222.40
46.102.13.75
50.16.51.244
72.64.66.90
64.134.99.94
76.15.125.189
60.234.234.87
68.104.250.24
68.104.119.113
24.131.160.211
75.85.175.34
75.144.106.30
81.248.6.96
67.204.32.131
189.81.35.48
80.167.121.150
72.241.115.41
64.213.65.34
75.76.221.65
99.159.30.126
75.186.15.85
2.99.42.233
64.206.171.18
82.171.78.148
24.16.12.6
67.235.251.192
69.81.64.175
2.108.19.246
24.63.124.114
67.166.24.185
67.167.123.120
46.59.16.42
24.129.21.181
74.129.37.170
76.94.59.185
129.244.4.211
74.211.20.246
79.103.163.127
50.19.84.12
74.125.59.33
74.109.63.168
82.27.167.14
24.127.224.86
24.18.76.91
74.104.168.101
66.189.126.66
87.206.171.51
75.187.55.142
69.164.206.221
24.235.184.116
76.167.184.35
50.46.159.9
82.224.151.216
66.93.40.111
24.15.103.111
76.103.174.110
24.246.73.139
79.202.79.240
24.161.69.163
62.64.102.102
69.28.43.17
81.86.124.96
72.222.149.223
61.8.8.170
67.23.71.26
80.101.134.8
76.94.101.62
66.119.51.122
75.141.136.152
50.72.195.144
70.66.157.224
24.136.6.113
67.8.206.56
76.102.237.113
75.205.215.187
71.237.71.32
80.99.181.12
62.178.52.33
50.56.122.182
24.191.63.54
83.4.136.203
64.183.143.74
81.219.0.8
66.31.36.46
67.188.215.9
71.61.223.99
24.155.216.135
81.234.132.169
81.229.123.145
86.44.128.159
81.134.134.100
75.57.124.176
95.49.49.216
69.181.144.230
63.249.118.188
70.178.59.151
76.230.232.226
69.172.116.177
98.220.173.17
81.130.67.21
69.107.102.93
66.207.218.163
24.83.177.109
41.133.185.85
64.199.117.226
67.180.16.221
209.51.65.26
68.5.18.117
12.175.182.178
76.127.178.8
67.2.23.39
85.228.218.136
94.188.40.190
41.238.202.120
67.177.156.219
78.145.67.12
82.69.45.234
24.78.115.31
78.137.61.106
66.65.73.230
68.4.75.185
68.111.12.19
71.181.35.195
74.197.167.37
70.170.43.36
66.134.37.10
76.186.253.231
69.23.41.208
79.119.16.137
24.137.70.207
24.43.21.2
92.8.165.82
75.69.94.132
128.192.151.196
76.88.86.199
216.144.203.40
75.15.202.159
74.192.1.143
68.188.161.130
69.133.7.215
41.135.38.242
70.41.205.244
74.62.215.90
64.121.86.132
71.198.134.9
77.99.190.151
70.90.223.70
75.69.146.137
78.61.15.112
75.72.232.136
72.200.64.112
71.199.123.47
74.115.0.30
72.206.98.111
69.91.180.189
83.19.46.6
71.191.184.64
74.116.187.243
98.243.14.161
50.15.13.110
91.124.156.27
82.38.249.190
70.71.171.223
24.170.231.19
75.102.197.85
91.156.102.176
76.115.154.222
71.192.79.252
70.90.113.193
24.176.85.8
74.105.231.137
69.151.240.152
24.172.162.34
74.9.152.196
75.37.74.30
71.45.153.85
75.200.115.205
24.1.170.29
67.185.245.44
69.165.147.219
74.141.126.228
82.69.78.148
74.12.5.6
24.130.178.235
87.79.152.8
84.253.77.110
62.29.253.200
2.92.20.61
69.181.97.152
78.134.25.138
97.64.197.29
67.6.53.196
81.23.54.165
24.22.51.216
75.143.226.13
71.221.16.141
65.40.146.38
76.105.16.10
76.191.142.239
24.246.60.168
74.130.51.72
24.78.182.162
174.107.149.104
90.185.49.137
213.93.92.45
64.208.116.145
81.187.55.94
71.196.201.1
74.103.30.184
84.73.91.20
74.111.112.69
98.247.190.121
83.101.1.217
46.64.54.20
69.204.255.9
24.148.56.46
24.93.230.157
75.1.100.201
208.83.233.194
87.206.119.109
75.151.101.190
70.176.132.94
77.44.175.51
81.102.245.169
67.174.3.137
66.194.3.238
69.23.228.104
69.25.135.196
69.164.56.1
80.229.77.139
24.201.117.189
79.97.253.216
24.196.174.28
74.57.67.237
77.223.192.26
95.34.210.239
24.236.202.221
76.226.119.221
70.52.85.95
91.77.235.30
71.255.65.151
88.217.64.64
72.144.191.116
75.162.15.64
24.136.39.61
77.13.124.59
2.49.195.249
63.80.168.2
58.8.88.234
70.228.79.239
68.198.199.78
77.12.11.24
66.65.187.180
76.126.10.159
68.205.178.236
66.188.3.146
71.76.156.216
66.233.197.253
66.191.92.48
79.141.157.43
24.60.165.38
72.48.250.88
96.49.171.130
79.142.230.73
188.17.185.245
98.117.221.83
84.212.110.148
76.115.100.96
98.218.167.224
4.28.37.210
68.233.192.138
66.129.59.192
72.240.155.71
72.135.206.191
41.132.173.186
76.185.22.78
74.33.18.174
68.104.164.215
68.68.41.205
50.37.203.92
80.92.102.136
95.90.22.62
76.16.43.248
70.167.47.106
75.201.157.209
68.111.187.217
69.243.168.98
77.71.43.92
80.132.22.104
82.173.179.213
84.142.159.128
97.101.66.120
67.148.10.162
71.98.248.241
67.168.100.139
62.198.44.152
70.116.158.211
80.239.93.22
24.22.43.222
71.76.248.121
75.85.109.122
70.190.192.186
75.77.4.133
72.204.34.69
76.22.117.41
75.72.130.109
69.117.22.174
69.125.10.100
75.191.176.202
12.189.178.10
142.177.154.99
71.63.136.108
70.246.129.119
174.121.109.162
76.10.214.53
93.178.214.118
71.198.192.39
87.194.207.93
76.114.138.159
77.253.121.108
78.235.2.6
75.92.62.236
69.165.161.10
71.234.31.133
32.176.188.151
46.70.74.249
67.182.102.143
46.73.66.218
66.169.234.30
67.226.189.9
65.185.46.112
60.234.30.66
70.19.20.101
98.251.57.254
75.69.206.251
68.3.127.123
46.147.135.173
69.40.135.169
78.26.85.217
50.9.207.124
72.232.178.194
67.215.251.246
204.237.12.62
99.246.96.36
4.58.7.81
24.250.243.145
91.79.152.140
46.126.184.62
79.160.47.195
76.177.106.56
67.169.81.72
24.162.110.216
71.58.104.111
50.54.145.165
69.119.44.252
66.50.151.145
68.83.220.30
195.200.253.239
64.30.123.157
66.219.45.164
70.126.106.6
69.11.112.90
79.191.66.153
77.99.190.136
76.74.203.52
76.17.239.137
83.248.138.37
68.254.162.180
24.23.181.190
75.139.154.177
80.5.15.173
71.237.0.244
18.177.0.108
75.160.65.225
96.246.232.64
72.178.99.131
98.160.241.54
80.222.144.135
75.65.0.71
66.87.5.162
75.59.196.2
76.95.12.74
66.41.57.215
68.68.193.20
78.28.17.132
81.97.236.214
24.170.162.51
77.250.166.100
76.169.174.153
50.17.100.252
74.178.178.112
74.215.38.30
70.191.80.159
75.143.68.89
24.116.73.10
59.167.13.219
70.15.23.249
84.212.220.28
75.75.0.97
76.66.11.219
76.104.40.202
62.75.137.235
66.215.69.139
97.101.53.51
62.168.243.26
67.169.43.25
69.196.165.44
69.107.72.151
62.16.214.120
27.32.192.51
109.173.109.39
75.81.244.208
46.102.240.249
66.227.149.247
67.102.33.58
77.255.231.0
68.144.208.72
82.34.196.205
24.57.211.154
71.13.74.241
68.80.51.26
24.100.154.59
71.232.61.130
76.10.180.68
69.196.133.148
92.70.112.34
74.104.175.25
12.94.123.66
62.61.159.170
75.151.29.65
24.154.252.147
76.19.160.58
78.52.124.81
24.22.206.10
78.109.190.87
24.224.220.107
68.5.141.127
75.71.65.152
68.186.3.38
81.132.127.100
77.40.23.4
46.162.106.208
68.183.224.194
99.243.130.80
69.181.59.162
129.21.125.117
68.144.125.160
77.96.176.122
2.125.236.45
24.23.221.203
78.47.250.163
91.156.28.192
77.102.215.222
68.81.221.221
62.162.121.226
85.217.17.89
67.11.139.148
82.169.182.52
173.19.150.34
98.247.18.82
68.148.102.140
70.119.204.45
24.22.233.78
60.52.56.142
71.232.18.60
75.128.2.12
109.107.36.233
79.161.218.122
46.9.91.170
58.96.65.118
69.143.153.132
77.115.156.248
77.161.105.189
93.56.54.172
67.184.49.54
75.67.160.233
81.198.158.161
99.93.24.201
24.45.254.107
71.236.30.27
76.242.145.53
70.173.154.177
65.96.165.26
69.59.97.181
65.35.54.82
64.9.146.30
76.24.188.79
76.205.169.86
75.80.241.215
79.157.69.175
68.16.1.132
67.68.185.114
72.14.187.30
76.208.50.208
18.111.115.98
68.146.12.215
24.45.128.140
71.201.43.61
74.70.97.185
95.72.52.42
99.23.198.197
71.143.231.140
69.180.232.34
24.189.147.96
70.124.65.110
72.161.132.104
24.129.25.232
70.91.8.105
24.47.208.164
212.34.117.112
79.135.211.163
75.140.122.143
69.15.121.155
72.90.74.215
89.77.196.110
65.67.113.81
72.134.25.64
82.229.212.98
65.28.70.80
81.205.167.191
76.17.204.103
69.50.217.128
78.8.129.66
58.171.233.223
74.99.150.26
74.88.175.131
72.225.215.108
70.127.113.77
41.185.113.125
72.161.254.116
71.61.127.82
74.95.106.214
69.84.244.131
69.47.154.147
71.202.23.110
84.148.112.84
69.114.185.40
59.105.218.133
76.104.217.135
82.124.217.152
68.179.176.26
67.6.85.174
75.70.31.6
67.78.251.170
68.144.64.231
68.225.237.174
76.115.103.62
83.160.63.64
76.112.56.241
71.231.136.4
75.143.102.16
72.219.21.29
66.57.168.42
41.135.16.8
24.176.52.57
70.128.73.6
66.96.16.50
69.253.194.104
175.107.146.57
24.59.72.167
81.228.145.45
24.89.193.84
71.22.108.167
76.64.14.57
69.196.173.229
65.183.133.148
46.5.244.38
146.164.99.242
83.101.78.72
78.35.128.31
76.226.174.173
150.162.10.8
68.12.174.226
78.8.58.4
83.160.98.10
24.85.79.152
76.174.199.98
66.220.186.158
68.71.77.135
67.186.119.39
62.24.245.203
24.245.21.197
68.228.170.162
64.4.1.10
99.229.78.42
71.233.75.13
83.4.209.179
98.28.183.13
66.65.94.115
62.220.33.25
77.255.44.160
71.199.181.196
85.165.133.252
76.172.56.116
76.126.155.120
87.194.153.245
207.192.72.150
75.44.216.131
74.129.247.175
84.28.70.221
199.44.153.1
71.1.155.213
24.224.108.192
67.181.152.205
69.62.228.204
74.163.4.228
68.146.23.18
24.67.135.58
75.181.85.4
76.102.153.97
67.190.131.212
24.30.34.40
67.197.66.46
68.15.88.234
69.76.21.66
69.196.191.75
50.48.37.151
72.204.31.119
80.223.137.80
76.200.180.183
68.96.49.119
80.116.121.11
67.166.202.204
66.66.102.77
76.2.0.111
207.161.52.104
24.27.19.30
78.175.67.43
76.6.4.20
68.183.17.153
74.184.130.250
67.249.14.228
66.229.182.106
27.32.136.254
76.85.165.110
79.188.186.242
98.242.206.177
80.138.25.27
70.113.73.53
77.243.65.200
67.130.216.253
75.72.178.183
75.107.125.241
71.170.84.211
99.230.182.160
75.109.99.96
74.67.65.79
84.28.115.96
79.236.188.67
67.180.205.93
77.162.94.135
71.227.232.12
71.202.28.238
78.105.146.197
76.181.39.238
91.76.83.254
76.94.59.23
108.16.237.57
82.75.91.82
38.104.78.166
74.70.223.56
62.195.195.96
71.43.12.242
78.56.220.67
79.140.18.133
98.109.63.161
72.38.82.230
203.206.227.1
50.53.74.200
46.33.22.218
71.183.228.60
71.8.197.38
75.18.168.114
174.252.171.145
188.187.151.23
24.153.207.244
24.158.173.127
68.104.105.112
67.182.208.24
67.82.100.66
72.148.190.187
24.150.176.34
69.205.151.120
76.8.137.66
80.116.125.61
77.239.232.169
67.78.241.13
76.182.11.55
79.136.61.194
77.70.58.243
74.233.167.75
70.88.15.244
63.127.234.86
66.245.3.230
66.11.168.76
75.145.180.210
80.217.192.183
24.119.79.190
68.234.0.130
24.73.252.170
94.122.94.42
71.105.43.44
71.94.90.116
69.71.247.134
68.7.235.145
69.116.225.141
86.19.138.123
69.28.36.135
82.194.219.253
75.131.11.156
24.21.78.90
24.116.133.114
67.18.92.220
190.210.28.245
50.53.96.23
62.254.17.35
64.4.99.40
24.20.183.82
75.181.168.241
89.126.16.235
78.70.63.178
71.168.75.203
70.81.207.187
72.128.90.236
71.63.19.44
50.8.106.170
82.45.126.245
70.104.119.59
71.198.46.165
70.124.63.160
68.57.192.122
24.130.12.194
24.99.134.234
69.160.245.131
72.253.224.57
67.62.89.51
202.89.33.165
67.247.14.71
24.46.236.208
76.101.66.78
91.125.48.180
70.43.14.34
68.198.84.123
89.100.207.202
186.18.74.158
24.246.75.208
72.174.50.53
93.97.70.22
72.71.247.91
72.71.247.94
70.119.119.133
66.150.164.226
71.223.236.37
80.70.2.223
24.154.47.59
79.191.37.246
75.144.178.1
46.98.29.163
77.237.14.149
69.50.10.30
80.221.19.20
66.169.243.134
67.186.104.58
71.205.177.49
69.144.38.17
95.96.98.149
70.78.216.231
64.56.122.130
69.74.205.147
75.25.41.151
60.228.245.92
70.53.51.13
108.5.43.98
62.233.241.132
82.168.164.219
71.231.177.119
80.90.120.7
50.17.24.80
86.44.133.1
95.168.184.149
24.13.159.62
67.168.201.88
108.28.102.34
24.77.78.94
70.45.50.195
69.196.147.88
178.32.115.163
24.136.100.218
24.57.221.122
174.17.24.24
62.75.218.18
75.139.222.6
66.30.145.224
71.130.198.209
87.205.154.75
70.129.226.91
24.84.70.166
66.61.27.118
66.65.190.111
24.187.175.96
71.203.224.210
79.136.88.70
71.194.9.33
84.79.213.31
71.163.238.27
74.192.19.135
60.240.208.52
67.63.86.82
67.188.212.51
84.234.128.4
75.101.150.245
65.121.95.194
75.73.233.172
70.128.122.217
75.95.193.107
76.24.80.252
98.196.226.47
24.22.123.148
70.70.154.216
74.84.228.149
50.72.198.100
24.128.224.254
84.90.108.41
92.229.28.158
24.182.108.174
75.149.224.133
70.79.3.109
69.224.57.6
24.107.2.10
80.221.5.90
2.83.42.156
82.239.246.83
24.205.237.146
70.253.70.245
76.192.162.104
69.30.224.137
69.30.224.135
71.136.51.49
68.199.249.213
60.50.83.111
70.113.120.14
79.247.90.3
68.57.229.58
68.3.209.161
77.254.130.169
78.9.150.232
76.186.162.241
76.122.14.42
69.140.178.81
75.32.4.83
69.165.142.155
75.72.6.219
77.49.218.203
80.249.255.234
50.53.29.76
67.187.98.70
74.219.123.194
71.123.181.200
75.52.184.110
72.94.243.196
213.165.184.215
71.233.150.176
69.111.194.100
24.77.203.69
84.209.81.224
66.190.88.45
67.248.191.56
68.162.111.233
68.2.109.142
67.204.13.200
81.210.72.188
71.115.12.95
65.39.160.178
65.160.41.6
64.119.57.230
24.18.33.9
72.200.179.125
67.167.195.46
78.86.119.31
41.133.102.24
72.43.172.200
24.119.123.141
72.177.60.241
173.81.199.48
24.196.44.184
76.31.207.37
67.90.232.82
68.144.188.70
46.9.169.246
85.86.132.130
24.46.141.0
69.38.208.114
65.32.64.186
50.16.134.245
76.126.67.73
78.23.123.183
71.125.64.108
74.95.191.60
62.57.145.48
38.126.103.131
70.114.196.63
72.65.98.158
78.92.127.152
76.254.5.70
50.43.41.5
24.201.11.70
96.44.168.111
78.60.48.9
69.111.73.99
67.4.193.68
24.243.2.151
78.105.162.132
66.195.151.26
72.179.58.45
46.6.215.182
69.140.99.156
24.222.129.75
65.92.13.145
178.55.131.219
69.31.167.51
65.50.112.160
76.27.234.244
12.0.86.130
71.71.199.227
75.133.42.65
24.99.179.152
207.81.162.223
67.188.228.172
69.122.233.78
68.111.218.76
75.68.104.68
66.229.249.174
71.215.125.177

On the Anonymous IP Leak

Posted in Uncategorized on May 14, 2011 by z4klon

I thought I might do a post concerning this whole fiasco with Anonymous having their IPs leaked (some of them at least).

Here’s the page where it came from: What I’m seeking to do is to see what exactly can be made from just a list of IPs.

So the first thing I did was to use a simple little python script to get all the IPs out of that whole mess, one per line. I did this in IDLE, so I don’t have it to post, but I do have the finished product:


88.191.130.138
91.54.251.198
217.18.70.232
70.112.202.234
99.235.158.83
109.205.169.8
155.212.199.2
82.229.58.165
93.190.93.208
68.93.103.64
67.80.211.11
82.233.73.234
67.134.55.209
80.79.116.250
81.66.201.208
178.73.192.19
108.35.80.200
108.35.80.200
80.26.227.7
74.115.210.37
202.20.5.34
218.185.230.1
99.31.211.84
202.20.5.34
85.17.167.217
72.20.41.71
68.48.32.134
184.106.219.248
98.196.185.250
98.145.170.45
24.56.56.156
77.251.49.162
87.106.138.9
93.182.190.91
74.74.143.139
88.80.28.189
84.182.123.168
76.106.130.164
89.46.166.18
71.227.15.215
108.20.46.63
72.251.202.133
204.188.216.2
89.204.153.189
189.216.66.16
81.169.165.187
121.241.128.145
74.34.29.162
90.12.222.165
124.190.58.40
86.27.31.44
178.73.193.102
208.53.156.36
62.220.250.75
66.224.3.190
216.197.226.5
89.238.176.99
112.203.41.67
89.155.19.222
91.125.50.79
198.151.130.69
88.190.22.89
125.237.99.196
98.223.121.172
130.64.142.192
130.64.142.228
85.69.142.194
82.73.114.120
195.145.198.234
178.73.192.69
67.172.213.167
74.97.41.96
178.63.193.184
46.4.200.249
84.123.31.51
87.152.223.205
70.84.208.197
92.194.71.47
96.229.144.13
110.175.54.224
92.149.238.100
85.214.130.233
184.18.160.41
108.16.193.214
190.251.128.182
83.202.142.134
74.39.212.101
72.27.80.236
85.230.242.57
77.190.212.245
89.100.133.159
76.249.179.148
213.171.222.94
195.249.185.5
98.193.244.20
70.48.120.110
67.249.254.252
82.241.89.219
76.75.3.54
90.62.134.139
83.52.197.146
109.61.7.242
46.38.162.88
178.73.192.220
195.192.29.20
77.185.208.254
85.31.186.70
85.31.186.70
24.4.13.219
85.220.75.199
67.193.150.15
70.112.4.14
95.211.10.3
85.17.141.187
66.183.49.60
67.167.59.176
98.148.26.113
74.240.96.172
27.3.110.131
2.49.53.0
108.7.51.224
184.147.16.91
178.73.222.93
80.254.74.39
81.49.128.28
71.228.72.30
216.18.226.202
60.229.148.78
188.28.67.20
86.6.205.40
208.99.89.166
94.175.64.122
178.73.220.50
98.87.219.119
188.121.236.38
69.122.98.137
71.196.153.215
202.175.143.143
83.80.167.121
201.230.83.245
80.3.151.213
98.111.13.87
184.73.223.150
190.166.205.84
89.242.137.177
81.241.162.32
208.97.140.69
199.255.209.72
200.8.23.8
64.131.7.76
76.249.179.148
95.93.67.183
80.254.74.16
68.230.119.62
68.230.119.62
68.230.119.62
68.230.119.62
188.129.122.216
212.93.30.130
86.159.166.238
93.207.50.95
68.104.173.250
46.21.207.188
124.171.47.162
114.76.203.66
86.186.223.93
195.88.15.2
77.249.186.203
89.143.155.199
188.141.105.65
198.151.130.65
122.61.223.43
147.83.182.26
85.214.54.17
66.235.44.179
64.34.3.140
2.37.31.246
24.3.174.81
178.73.218.222
178.73.221.30
195.68.125.185
174.131.83.190
80.237.225.145
204.130.172.10
77.190.23.158
199.19.227.74
70.26.249.107
91.115.119.64
24.161.27.43
24.161.27.43
88.159.124.43
188.241.116.32
189.216.12.81
62.47.254.29
24.108.95.110
178.73.221.107
173.0.5.204
173.0.7.148
67.160.23.98
75.69.123.16
173.0.0.160
188.165.233.80
212.224.65.89
69.57.122.81
109.226.14.126
46.253.205.212
85.156.203.153
85.156.203.153
174.96.116.161
24.2.143.233
217.114.113.41
203.208.100.127
217.18.70.231
99.249.34.193
84.201.42.145
70.15.145.83
84.202.165.41
213.98.140.103
78.142.179.175
69.140.80.120
173.255.231.159
173.162.31.14
77.253.80.41
71.232.220.173
94.220.140.128
178.73.218.97
177.16.58.192
186.73.56.10
24.79.43.195
173.0.6.102
174.36.215.196
66.183.31.211
174.127.64.104
192.94.73.15
86.61.125.68
95.17.152.43
66.229.20.155
76.252.36.71
141.156.136.213
81.71.53.254
213.98.140.103
190.66.110.244
81.241.162.32
66.190.10.50
78.251.120.174
203.167.189.157
71.236.25.229
178.73.192.41
76.106.235.132
110.174.134.183
173.0.11.232
74.136.139.68
122.57.127.5
46.182.121.224
46.21.146.28
213.93.228.203
184.106.81.127
50.17.105.161
118.210.79.130
118.210.79.130
75.41.183.237
178.73.221.30
80.67.176.109
92.103.12.150
66.212.155.157
122.60.161.195
80.67.176.175
188.40.142.12
190.251.211.130
62.235.187.101
195.225.106.107
90.149.165.77
195.225.106.107
67.172.213.167
92.238.237.152
2.89.190.192
80.254.74.39
96.39.237.207
213.98.140.103
90.209.254.27
79.175.78.179
2.220.205.166
195.225.106.107
184.35.27.24
195.225.106.107
216.66.24.2
203.171.197.32
207.150.179.142
195.3.137.242
68.145.78.211
80.246.57.55
80.246.57.55
190.255.127.149
71.188.32.130
24.26.63.98
174.34.131.132
93.12.37.31
88.177.155.161
86.24.135.98
78.192.81.40
207.44.162.229
24.132.96.149
74.89.112.107
173.255.210.107
90.215.68.155
93.48.255.114
98.67.217.79
186.32.47.13
24.182.67.114
178.73.198.37
212.224.65.89
87.232.45.146
87.194.43.245
184.97.19.43
60.234.212.78
71.181.172.104
65.8.32.23
202.175.143.143
24.57.222.219
173.0.10.217
124.155.38.177
85.91.28.196
77.251.154.99
82.228.142.248
212.128.135.113
84.202.50.81
68.184.239.188
72.164.132.23
62.47.236.223
108.13.218.189
161.53.18.95
178.79.139.185
180.131.236.218
195.112.47.174
209.250.254.9
216.59.101.194
79.170.88.34
67.235.39.195
90.163.56.246
178.73.192.150
24.213.35.92
178.22.65.88
178.73.192.96
178.223.0.185
24.20.112.244
188.126.75.244
213.179.212.116
99.150.132.143
90.231.48.97
85.151.0.26
86.175.106.159
76.73.68.198
130.126.15.0
178.202.154.162
68.102.224.29
91.205.184.172
92.103.125.220
178.73.221.64
89.204.153.189
69.249.241.228
70.29.155.243
68.161.243.57
124.168.158.211
69.197.49.62
178.63.122.124
150.135.211.242
208.54.5.71
72.193.164.39
178.73.194.220
91.185.208.188
178.73.193.15
83.215.5.109
84.19.178.6
95.120.130.255
81.125.122.43
88.179.54.170
99.251.204.45
93.94.245.13
93.94.245.59
60.28.240.60
115.64.55.136
93.185.104.26
24.85.242.7
223.27.170.124
87.185.124.153
72.240.102.219
70.75.75.193
79.102.210.117
212.33.138.202
67.220.74.51
188.116.36.66
83.34.37.219
86.147.115.149
27.32.116.72
24.45.246.10
178.73.192.102
124.217.231.162
24.246.69.226
136.206.15.24
74.124.13.13
173.57.180.64
98.67.217.79
62.235.187.101
81.172.91.165
98.246.133.8
208.54.37.69
204.8.223.10
178.73.196.139
212.182.165.44
173.72.137.119
99.39.212.85
87.238.35.13
72.25.33.78
137.248.143.48
76.87.69.67
212.204.128.12
94.169.71.243
217.172.33.15
75.12.91.68
217.69.165.141
85.10.192.137
115.64.48.29
124.195.206.55
190.166.121.215
72.23.119.90
64.134.238.135
178.73.221.49
173.0.2.210
108.0.75.93
64.22.109.238
72.223.84.45
95.130.11.139
188.165.21.84
184.57.98.239
95.17.126.83
2.210.234.30
178.79.129.142
81.84.184.219
24.161.146.14
199.68.198.129
75.20.152.34
77.164.246.3
123.51.97.91
71.192.116.159
91.121.95.138
24.18.251.229
124.169.223.232
87.101.35.171
66.96.251.117
81.11.245.157
79.175.78.179
203.98.18.214
217.13.30.115
77.249.248.110
174.136.97.106
24.201.195.146
174.34.131.134
178.73.223.74
87.227.96.214
109.205.169.30
82.195.234.50
70.166.246.234
212.189.140.211
188.165.64.124
206.125.173.242
72.193.164.39
50.17.94.64
74.86.7.106
77.223.209.7
212.83.72.21
195.81.7.217
68.230.119.62
68.230.119.62
122.61.156.4
174.1.148.63
188.141.117.231
75.132.186.102
213.180.92.129
67.83.145.178
178.21.113.147
80.254.66.41
195.190.179.4
69.203.146.201
93.94.245.138
81.60.0.100
217.18.70.234
216.18.226.231
92.7.242.73
46.208.27.177
96.8.198.144
66.87.0.159
121.72.182.102
178.79.153.11
85.214.71.145
88.190.226.108
66.49.176.140
187.104.116.150
178.24.199.51
93.190.93.96
166.165.145.120
213.239.202.137
24.218.208.126
140.160.139.252
50.53.189.73
184.73.126.111
213.229.64.96
65.40.25.130
212.224.65.4
93.94.245.80
118.157.24.29
24.59.228.130
61.195.154.1
66.93.241.126
66.27.168.196
114.78.169.158
166.84.7.19
178.24.199.51
77.189.200.224
122.60.161.195
66.93.203.152
69.137.25.129
173.76.221.65
173.76.221.65
173.76.221.65
173.76.221.65
109.205.169.25
217.114.62.129
92.105.125.68
180.191.13.253
80.254.75.17
173.162.122.197
173.33.8.4
96.48.73.135
173.255.227.45
203.184.29.250
67.239.45.203
72.8.156.78
213.10.159.46
114.77.119.21
76.94.22.162
93.191.129.34
115.64.105.213
86.47.72.189
173.0.4.233
72.222.198.232
87.143.53.50
90.209.254.27
173.0.10.214
67.217.160.100
24.13.198.237
75.34.38.78
71.205.207.0
208.78.101.68
81.220.120.232
174.143.244.95
85.164.230.252
184.244.213.25
68.230.86.191
87.146.81.155
173.0.2.236
68.91.80.60
193.71.166.204
98.193.221.91
97.114.55.252
99.198.122.71
188.193.40.222
124.169.75.193
93.94.244.10
109.153.197.159
94.210.96.100
98.200.58.94
86.42.28.24
173.0.7.173
68.55.59.154
92.149.76.126
82.238.120.144
84.185.168.99
84.185.168.99
98.71.210.63
174.34.131.133
87.151.172.144
213.246.52.82
81.56.201.125
89.238.176.99
24.63.88.164
188.177.129.162
83.16.51.18
83.16.51.18
213.186.59.104
77.193.204.17
68.37.43.156
151.13.142.34
50.16.154.181

I took out all the 127′s as well; why they weren’t removed in the original is beyond me!

After that, you could do something like nmapping all of them, looking for additional info on specific ports that may/may not be of additional value; try to geolocate said IPs, do whois lookups, etc. Honestly, IPs alone aren’t of that much value, but I always like to comb through a list to find the one or two interesting bits out of the many. Mainly, I like to come across sites I’d ordinarily never come across before; much less for something like Anonymous members, lol.

For that, I did something like

nmap -iL list.txt -p 80 > output.txt

You should also note that many of these IPs aren’t going to be the same persons who were on Anon IRC anyway; many ISPs dynamically allocate IPs, so what is someone’s IP one day isn’t necessarily the same as what they had yesterday. These records are somewhat old and thus may not be accurate; the accuracy of anything found that’s tied to a given IP is inversely proportional to its age, in other words.

Follow

Get every new post delivered to your Inbox.