[test-suite] Adding Pathfinder Benchmark

[homerdin]

Summary

Description:

PathFinder searches for "signatures" within graphs. Graphs being searched are
directed and cyclic. Many, but not all nodes within the graph have labels. Any
given node may have more than one label, and any label may be applied to more
than one node. A signature is an orderd list of labels. PathFinder searches for
paths between labels within the signature. PathFinder returns success if there
is a path from a node with the first label in the signature that passes through
nodes with each label in order, ultimately reaching a node with the last label
in the signature. Labeled nodes need not be contiguous on any given path.

At the current time, PathFinder does not do any pathway analysis (e.g. shortest
path) for discovered signatures. PathFinder simply searches until a signature is
satisfied or all pathways have been exhausted.

Links:

Web: https://mantevo.org/packages/
Github: https://github.com/Mantevo/PathFinder

When run on Intel(R) Xeon(R) CPU E5-2699 v4 @ 2.20GHz:

compile_time: 13.3092 
exec_time: 3.1158 
Maximum resident set size (kbytes): 6256

[MatzeB]

• Integration looks good to me
• I'd like to hear some clarification on the license in the file headers
• You could add a REAMDE file describing the benchmark in the benchmark directory

MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/bitfield.h

7–9 ↗

(On Diff #110958)

See my comments in D36683

[homerdin]

Hi, I've added the original README with a note at the top.

[• dberlin]

This is the same as what i said on D36682 :)

[MatzeB]

LGTM

[hfinkel]

A couple of things I'll fix while committing...

MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/main.c

81 ↗

(On Diff #111394)

This must be signed char or else it can never be equal to -1 below on platforms, such as PowerPC, where char is unsigned.

MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/searchAlgorithms.c

452 ↗

(On Diff #111394)

Likewise, having this go to stderr can lead to a confusing output ordering.

545 ↗

(On Diff #111394)

Having this go to stderr can lead to confused ordering with the other outputs.

test-suite/trunk/LICENSE.TXT

 oggenc:             llvm-test/MultiSource/Applications/oggenc
 JM:                 llvm-test/MultiSource/Applications/JM
 ALAC:               llvm-test/MultiSource/Applications/ALAC
 ASC Sequoia:        llvm-test/MultiSource/Benchmarks/ASC_Sequoia/AMGmk
                     llvm-test/MultiSource/Benchmarks/ASC_Sequoia/IRSmk
                     llvm-test/MultiSource/Benchmarks/ASC_Sequoia/sphot
 smg2000:            llvm-test/MultiSource/Benchmarks/ASCI_Purple/SMG2000
 miniAMR:            llvm-test/MultiSource/Benchmarks/DOE-ProxyApps-C/miniAMR
+Pathfinder:         llvm-test/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder
 XSBench:            llvm-test/MultiSource/Benchmarks/DOE-ProxyApps-C/XSBench
 HPCCG:              llvm-test/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG
 PENNANT:            llvm-test/MultiSource/Benchmarks/DOE-ProxyApps-C++/PENNANT
 miniFE:             llvm-test/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE
 Fhourstones:        llvm-test/MultiSource/Benchmarks/Fhourstones
 Fhourstones-3.1:    llvm-test/MultiSource/Benchmarks/Fhourstones-3.1
 McCat:              llvm-test/MultiSource/Benchmarks/McCat
 Olden:              llvm-test/MultiSource/Benchmarks/Olden

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/CMakeLists.txt

 add_subdirectory(XSBench)
+add_subdirectory(Pathfinder)
 add_subdirectory(miniAMR)

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Makefile

 # MultiSource/DOE-ProxyApps-C Makefile:  Build all subdirectories automatically
 
 LEVEL = ../../..
 PARALLEL_DIRS = XSBench    \
-                miniAMR
-
+                miniAMR    \
+                Pathfinder
 
 include $(LEVEL)/Makefile.programs

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/CMakeLists.txt

+set(PROG PathFinder)
+list(APPEND LDFLAGS -lm)
+set(RUN_OPTIONS -x ${CMAKE_CURRENT_SOURCE_DIR}/medsmall1.adj_list) 
+llvm_multisource()

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/COPYING

+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/COPYING.LESSER

+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/Makefile

+LEVEL = ../../../..
+
+PROG = PathFinder
+LDFLAGS = -lm
+RUN_OPTIONS = -x $(PROJ_SRC_DIR)/medsmall1.adj_list 
+include $(LEVEL)/MultiSource/Makefile.multisrc

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/PathFinder.reference_output

+
+
+        PathFinder: finding a series of labeled nodes within a
+                two-layer directed, cyclic graph.
+               Copyright (2013) Sandia Corporation
+
+ Sandia National Laboratories is a multi-program laboratory managed and
+ operated by Sandia Corporation, a wholly owned subsidiary of Lockheed
+ Martin Corporation, for the U.S. Department of Energy's National Nuclear
+ Security Administration under terms of Contract DE-AC04-94AL85000,
+ there is a non-exclusive license for use of this work by or on behalf
+ of the U.S. Government. Export of this program may require a license 
+ from the United States Government.
+
+
+  500 functions specified
+  3463 basic blocks specified
+  371 total System Call Map elements
+  ...parsing complete.
+Immediately before parallel
+
+
+44669 found out of 137641 searches. Overall Time: 0:0:0.000
+
+
+Total 44669 legs found
+
+exit 0

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/README

+**************************************************************************
+LLVM Test-suite Note:
+**************************************************************************
+The original source is located at https://github.com/Mantevo/PathFinder.
+Beyond this paragraph is the original README contained with the source 
+code.  The Makefile refered to within is not utilized within the 
+test-suite.  The test-suite builds a serial version (openmp and 
+mpi disabled) with its own cmake and make build system.
+**************************************************************************
+
+PathFinder graph pathway analysis mini-application
+
+------------------------------------
+Contents of this README file:
+1. PathFinder overview
+2. PathFinder versions
+3. Building PathFinder
+4. Running PathFinder
+5. PathFinder search algorithm/pseudo code
+------------------------------------
+
+------------------------------------
+1. PathFinder overview:
+
+PathFinder searches for "signatures" within graphs. Graphs being searched are 
+directed and cyclic. Many, but not all nodes within the graph have labels. Any 
+given node may have more than one label, and any label may be applied to more 
+than one node. A signature is an orderd list of labels. PathFinder searches for 
+paths between labels within the signature. PathFinder returns success if there 
+is a path from a node with the first label in the signature that passes through 
+nodes with each label in order, ultimately reaching a node with the last label 
+in the signature. Labeled nodes need not be contiguous on any given path. 
+
+At the current time, PathFinder does not do any pathway analysis (e.g. shortest
+path) for discovered signatures. PathFinder simply searches until a signature is
+satisfied or all pathways have been exhausted.
+
+------------------------------------
+2. PathFinder versions:
+
+- PathFinder_ref:
+    reference version: self-contained. Includes serial and OpenMP parallel
+    implementations. MPI is not yet supported.
+
+------------------------------------
+3. Building PathFinder:
+
+The standard build is to cd into the 'PathFinder_ref' directory and type 'make'.
+Doing so builds an OpenMP enabled version of PathFinder (named PathFinder.x). For
+serial execution, run it with the OMP_NUM_THREADS environment variable set to 1.
+
+Alternative build targets:
+    * clean -- removes all .o files
+    * realclean -- removes all .o and .x files
+    * debug -- PathFinder.x+dbg - serial executable with debug information
+    * mpi -- currently not implemented; prints an error message
+    
+To verify execution, type 'make check' which builds a serial version, runs it
+against one of the known data sets and compares the results.
+
+------------------------------------
+4. Running PathFinder:
+
+The simplest execution is to simply type './PathFinder.x'. This will run 
+PathFinder with a trivial graph (MicroTestData.adj_list in the source 
+directory). It will find 6 legs out of 9 searches, by doing an "exhaustive" 
+search on that graph.
+
+An exhaustive search is PathFinder determining if paths exist between any pair
+of labels for every label existing in the graph. Exhaustive searches are 
+embarrassingly parallel, and can be quite time consuming depending on the size
+of the graph and number of labels. Running PathFinder exhaustively is done with
+the -x switch:
+    PathFinder.x -x <data file> 
+    e.g. PathFinder.x -x ../scaleData/1kx750.adj_list
+
+To search for specific signatures, PathFinder can be run interactively or with
+a configuration file. To run interactively, use the -i switch:
+    PathFinder.x -i <data file>
+PathFinder will prompt the operator for a series of labels to define the 
+signature for which PathFinder will search.
+
+Multiple data files and multiple signatures can be specified to PathFinder in a
+configuration file. A python script (config_builder.py) exists to assist the
+operator in creating a configuration file. A sample configuration file is 
+included in the PathFinder source directory. To run PathFinder with a config 
+file, use the -c switch:
+    PathFinder.x -c <config file>
+    e.g. PathFinder.x -c sampleConfig
+
+Typing 'PathFinder -h' will print a help message describing the available 
+execution switches. Sample data files are provided in the 'data' and 
+'generatedData' directories. The python script used to generate representative 
+graph data is in the PathFinder_ref directory. It is named graph_gen.py.
+
+YAML output files can be generated by using the -y switch.
+
+Sample data sets are included in the "generatedData" and "scaleData"
+subdirectories. The scaleData files are intended for performance
+characterization. They are named with the convention:
+    <NodeCount>x<LabelCount>.adj_list
+For expected results, see scaleData/README
+
+------------------------------------
+5. PathFinder search algorithm / pseudo code
+
+PathFinder does a modified depth-first search through the graph. For each 
+signature, PathFinder begins searching from the set of nodes which have the
+first label in the signature. From these nodes, it finds a path to any node that
+is labeled with the second label in the signature. This is repeated until a path
+is found to the last label in the signature. If at any point in the search a 
+path to a label is not found, that search fails.
+
+Searches are done recursively. At each node, the target of each edge is checked
+to see if it is labeled with the next label in the signature. If a match is 
+made, The search continues from the matched node and the subsequent label in the
+signature. If there are no remaining labels in the signature, the search has 
+succeeded. If no direct edge from the current node matches, then the search
+continues recursively for the current label along each edge from the current
+node. If no match exists along any edge, the search fails.
+
+Pseudo code:
+
+For each file in config file:
+    Parse file into a Graph
+    
+For each signature in config file:
+    Store for processing
+
+For each signature
+{
+    For each Graph
+    {
+        Make sure the graph contains at least one node labeled with every label 
+            in the signature
+
+        Get set of nodes with signature[0], the first label in signature
+        for each “Start” node
+        {
+            // Recursive procedure to find remaining signature. Requires
+            // current node, the remaining “unfound” signature legs
+            // a result stack of nodes to store path traversed and
+            // a stack of nodes visited so far to detect cycles and
+            // redundant searches
+            Create empty result stack
+            Create empty visited stack
+            success = FindRemainingSignatureFromCurrentNode ( startNode, 
+                                                &signature[1], result, visited )
+        } // end of for each “Start” node
+    } // end of for each Graph
+} // end of for each Signature
+
+
+// Recursive procedure to find remaining signature.
+//      currentNode – the node whose edges *might* reach the
+//                    next label in the signature
+//      signature – an array of pointers to C strings. These strings
+//                  are the labels being matched by the nodes being
+//                  searched. Each sequential pair of labels is a
+//                  “leg” of the search. The last pointer is NULL to
+//                  terminate the array.
+//      result – a stack of nodes containing the path currently
+//               traversed to reach this node
+//      visited – a stack of ALL nodes searched during the attempt
+//                to find the current label
+
+boolean FindRemainingSignatureFromCurrentNode ( currentNode, signature, result,
+                                                    visited )
+{
+    If currentNode is in visited
+        return FALSE – we have reached a cycle or a subgraph that has
+                       already been searched
+    else
+        push currentNode onto visited stack
+
+    push currentNode onto result stack
+    For each edge from currentNode
+    {
+        If edge->targetNode->label == signature[0]
+        {
+            If signature[1] != NULL we have more legs in the search
+                Create nextResult for next leg search
+                Create nextVisited for next leg search
+                success = FindRemainingSignatureFromCurrentNode 
+                                    ( edge->targetNode, &signature[1],
+                                      nextResult, nextVisited )
+                if success
+                    result += nextResult
+                    delete nextVisited
+                    return TRUE, we’ve found the path
+                else
+                    continue through edge checking
+            else signature[1] == NULL
+                push edge->targetNode onto result
+                return true, we’ve found the path
+        }
+        else
+            continue through edge checking
+    } // end of for each edge target compared against signature [0]
+
+    // If we’ve made it this far, none of the edges is a direct
+    // match to the current label, do a deeper search
+    For each edge from current node
+    {
+        success = FindRemainingSignatureFromCurrentNode ( edge->targetNode, 
+                                    &signature[0], result, visited )
+        if success
+            return TRUE, we’ve found the path
+        else
+            continue through edge searching loop
+    }
+
+    // If we’ve made it this far, we have no path
+    pop currentNode off of result (but not off of visited)
+    return FALSE;
+} // end of find remaining signature
+
+
+
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/bitfield.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+#ifndef BITFIELD_H
+#define BITFIELD_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct NodeStruct;
+
+/* --------
+ * Bitfield is a mask around a character pointer. An array of character
+ * pointers is allocated such that there is a sequence of available bits
+ * equal in length to the number of nodes in a given graph. Bitfield
+ * defines operations that check if a bit corresponding to a node index
+ * is set. This is used by the graph traversal path finding algorithms
+ * to determine if a node has been visited.
+ */
+
+typedef struct BitfieldStruct Bitfield;
+
+struct BitfieldStruct
+{
+    int bitsNeeded; /* in BYTES!!! */
+    char *bitfield;
+};
+
+
+Bitfield *Bitfield_new(int bitsNeeded); /* constructor */
+void Bitfield_delete(Bitfield *this); /* destructor */
+
+/* Returns true if the specified node has been visited */
+bool Bitfield_nodeVisited(Bitfield *this, struct NodeStruct *node);
+
+/* Makes a byte-by-byte copy of the "from" bitfield */
+Bitfield *Bitfield_copy(Bitfield *from);
+
+void Bitfield_clear();
+
+#endif
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/bitfield.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+#include "bitfield.h"
+#include "node.h"
+#include <stdio.h>
+
+
+/* --------
+ * Bitfield is a mask around a character pointer. An array of character
+ * pointers is allocated such that there is a sequence of available bits
+ * equal in length to the number of nodes in a given graph. Bitfield
+ * defines operations that check if a bit corresponding to a node index
+ * is set. This is used by the graph traversal path finding algorithms
+ * to determine if a node has been visited.
+ */
+
+
+/* constructor */
+Bitfield *Bitfield_new(int bitsNeeded)
+{
+    int size = (bitsNeeded+7) / 8; /* CHAR_BIT; */
+    Bitfield *new = malloc(sizeof(Bitfield));
+    if ( !new )
+        return(NULL);
+    new->bitfield = calloc(size, sizeof(char));
+    if ( !new->bitfield )
+    {
+        free(new);
+        return(NULL);
+    }
+
+    new->bitsNeeded = bitsNeeded;
+    return new;
+} 
+
+/* destructor */
+void Bitfield_delete(Bitfield *this)
+{
+    if ( this )
+    {
+        if ( this->bitfield )
+            free(this->bitfield);
+        free(this);
+    }
+}
+
+/* Returns true if the specified node has been visited */
+bool Bitfield_nodeVisited(Bitfield *this, struct NodeStruct *node)
+{
+    int index = node->nodeCount >> 3;
+    char byte = this->bitfield[index];
+    char bit = 1 << (node->nodeCount & 0x07);
+    bool set = byte & bit;
+
+    this->bitfield[index] |= bit;
+
+    /* printf ( "Inside Bitfield nodeVisited: Node: %d, index %d, byte %x, bit: %x\n",
+             node->nodeCount, index, byte, bit ); */
+    return(set);
+}
+
+
+/* Makes a byte-by-byte copy of the "from" bitfield */
+Bitfield *Bitfield_copy(Bitfield *from)
+{
+    int i;
+
+    if ( !from )
+        return(NULL);
+
+    Bitfield *new = Bitfield_new(from->bitsNeeded);
+    if ( new )
+    {
+        for ( i = 0; i*8 < from->bitsNeeded; ++i )
+            new->bitfield[i] = from->bitfield[i];
+        return(new);
+    }
+    else
+        return(NULL);
+}
+
+
+void Bitfield_clear(Bitfield *this)
+{
+    int size = (this->bitsNeeded+7) / 8;
+    memset(this->bitfield, 0, size);
+}

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/configuration.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+
+/*
+ * configuration.h
+ *
+ *  Created on: October 1, 2013
+ *      Author: Brian "Rig" Rigdon
+ */
+
+#ifndef CONFIGURATION_H_
+#define CONFIGURATION_H_
+
+#include <stdbool.h>
+#include "graph.h"
+#include "graphGen.h"
+
+/* I was hoping to avoid this - however because we are dealing with
+ * pointers to arrays of pointers, passing the address of an such
+ * a beast becomes really confusing: Graph *(**pointer)[]
+ * Ergo, I am building a structure to contain all the information
+ * necessary for a given running of this software. For lack of
+ * a better name, we are calling it the "configuration".
+ */
+
+/* A simple enum to define which search is to be done */
+typedef enum { treeSearch, diagramSearch } SearchType;
+
+typedef struct SearchOptionsStruct SearchOptions;
+struct SearchOptionsStruct
+{
+    SearchType searchType;
+    bool multiThreaded;
+    bool doStatistics;
+    bool writeOutputFile;
+    char *outputFile;
+    BuildType buildType;
+};
+
+SearchOptions * SearchOptions_new();
+
+typedef struct ConfigurationStruct Configuration;
+struct ConfigurationStruct
+{
+    Graph **graphs; /* a pointer to a NULL terminated array of pointers */
+    Signature *signatures; /* a pointer to a NULL terminated array of Signatures */
+    SearchOptions *searchOptions;
+    int qThreadCount; /* recursion depth to STOP spawning new tasks */
+};
+
+Configuration* Configuration_new();
+
+#endif /*  CONFIGURATION_H_  */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/configuration.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * configuration.c
+ *
+ *  Created on: October 1, 2013
+ *      Author: Brian "Rig" Rigdon
+ */
+
+#include <stdio.h>
+ #include "configuration.h"
+
+ SearchOptions* SearchOptions_new()
+ {
+    SearchOptions *options = malloc(sizeof(SearchOptions));
+    if ( !options )
+        return(NULL);
+    options->searchType = treeSearch;
+    options->multiThreaded = false;
+    options->doStatistics = false;
+    options->writeOutputFile = false;
+    options->outputFile = NULL;
+    options->buildType = endNodesOnly;
+    return(options);
+ }
+
+ Configuration* Configuration_new()
+ {
+    Configuration *new = malloc(sizeof(Configuration));
+    SearchOptions *options = malloc(sizeof(SearchOptions));
+    if ( !new || !options )
+    {
+        if ( new ) free(new);
+        if ( options ) free(options);
+        return(NULL);
+    }
+    new->graphs = NULL;
+    new->signatures = NULL;
+    new->searchOptions = options;
+    new->qThreadCount = 0;
+    return(new);
+ }

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/gettime.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+#include <sys/time.h>
+#ifdef USE_OMP
+#include <omp.h>
+#endif
+
+extern double currentTime()
+{
+#ifdef USE_OMP
+    return omp_get_wtime();
+#else
+    return 0;
+#endif
+}
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/graph.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+
+/*
+ * Graph.h
+ *
+ *  Created on: Jan 9, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+
+/* --------
+ * Graphs are made up of nodes and edges. Nodes hold data and edges
+ * connect nodes to each other. In this representation, edges are
+ * directional (they lead from one node to the next) and may create
+ * looped paths. The data sets from which these graphs are defined
+ * define two-layered graphs. The outer layer may contain one or
+ * more interior nodes. These interior nodes may be linked among each
+ * other. Each containing node may have up to two "entrance" nodes;
+ * that is, an edge goes from the containing node to its entrance node.
+ *
+ * As mentioned above, the graphs are defined in data files. The graph
+ * data structure contains the file name, a count of nodes, a list of
+ * exterior nodes, and structures that assist in the searching through
+ * the graph for "signatures"
+ */
+
+#ifndef GRAPH_H_
+#define GRAPH_H_
+
+#include <stdbool.h> /* bool is no longer part of the C language */
+#include "node.h"
+#include "searchDiagram.h"
+#include "systemCallMap.h"
+
+
+/* -------------------------------------------
+ * Graph Definitions
+ *
+ */
+
+typedef struct GraphStruct Graph;
+
+struct GraphStruct
+{
+    char *fileName; /* the file parsed to give us this graph */
+    int totalNodes; /* Nodes, both outer and interior */
+    NodeList *outerNodes; /* The Linked-List capture of the node data */
+    SearchDiagram *searchDiagram; /* The compressed Node/Edge search structures */
+    SystemCallMap *systemCallMap;
+};
+
+
+/* "methods" */
+
+Graph *Graph_new(); /* Graph constructor */
+void Graph_delete( Graph *trash ); /* Destructor - erases current graph */
+bool Graph_addOuterNode( Graph *graph, Node *newOuterNode );
+/* Finds a node within the graph. If deep is true, we check interior nodes as well.
+ * If deep is false, we only check to see if the id is an outer node. This does NOT
+ * find the path to the node.
+ */
+Node *Graph_findNode( Graph *graph, int id, bool deep );
+
+
+
+/* Determine if a given node contains the node specified by id. If this problem extended
+ * beyond two layers, this method would be recursive. Returns NULL if node is not contained.
+ * This does NOT find the path to the node.
+ */
+Node *Graph_findContainedNode( Node *node, int id );
+
+
+#endif /* GRAPH_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/graph.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * graph.c
+ *
+ *  Created on: Jan 9, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+/* --------
+ * Graphs are made up of nodes and edges. Nodes hold data and edges
+ * connect nodes to each other. In this representation, edges are
+ * directional (they lead from one node to the next) and may create
+ * looped paths. The data sets from which these graphs are defined
+ * define two-layered graphs. The outer layer may contain one or
+ * more interior nodes. These interior nodes may be linked among each
+ * other. Each containing node may have up to two "entrance" nodes;
+ * that is, an edge goes from the containing node to its entrance node.
+ *
+ * As mentioned above, the graphs are defined in data files. The graph
+ * data structure contains the file name, a count of nodes, a list of
+ * exterior nodes, and structures that assist in the searching through
+ * the graph for "signatures"
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <math.h>
+
+#ifdef USE_OMP
+#include <omp.h>
+#endif
+
+#include "graph.h"
+#include "systemCallMap.h"
+#include "bitfield.h"
+#include "utils.h"
+
+
+
+
+/* -------------------------------------------
+ * Graph Method Definitions
+ *
+ */
+/* We deleted the code that made a graph singleton. Now we may have
+ * more than one graph. Ergo, the main method (or whatever) will maintain
+ * the graph pointer.
+ */
+
+Graph *Graph_new()
+{
+    Graph *graph= NULL;
+    graph = malloc( sizeof( Graph ));
+    if ( graph )
+    {
+        /* The malloc worked! */
+        graph->fileName = NULL;
+        graph->totalNodes = 0;
+        graph->outerNodes = NULL;
+        graph->searchDiagram = NULL;
+    }
+
+    return( graph );
+}
+
+/* Destructor - erases current graph, sets singleton to NULL */
+void Graph_delete( Graph *trash )
+{
+    SearchDiagram *element;
+    if ( trash )
+    {
+        free( trash->fileName );
+        NodeList_clear( trash->outerNodes, true );
+        if ( trash->searchDiagram ) {
+            for ( element = trash->searchDiagram; element->node != NULL; ++element )
+            {
+                free( element->edgeReferenceArray );
+            }
+            free( trash->searchDiagram );
+        }
+        free( trash );
+    }
+}
+
+bool Graph_addOuterNode( Graph *graph, Node *newOuterNode )
+{
+    /* a little basic error checking */
+    if ( !graph || !newOuterNode )
+        return (false);
+
+    /* Is this the first outer node? */
+    if ( graph->outerNodes == NULL ) /* Allocates singletonGraph if it's not there */
+        {
+        graph->outerNodes = NodeList_new();
+            if ( !graph->outerNodes )
+                return( false ); /* the malloc failed */
+            graph->outerNodes->node = newOuterNode;
+            return( true );
+        }
+
+    /* Otherwise, insert the new node at the tail of the singleton graph */
+    return( NodeList_insertBack( graph->outerNodes, newOuterNode ));
+}
+
+
+/* Finds a node within the graph. If deep is true, we check interior nodes as well.
+ * If deep is false, we only check to see if the id is an outer node. This does NOT
+ * find the path to the node.
+ */
+Node *Graph_findNode( Graph *graph, int id, bool deep )
+{
+    NodeList *nodes;
+    Node *node;
+
+    for ( nodes = graph->outerNodes; nodes != NULL; nodes = nodes->nextNode )
+    {
+        if ( nodes->node->id == id )
+            return( nodes->node );
+        /* If that wasn't the node, and we're going deep, see if it's there. */
+        if ( deep )
+        {
+            node = Graph_findContainedNode( nodes->node, id );
+            if ( node )
+                return( node );
+        }
+    }
+
+    return( NULL );
+}
+
+
+
+
+/* Determine if a given node contains the node specified by id. If this problem extended
+ * beyond two layers, this method would be recursive. Returns NULL if node is not contained.
+ * This does NOT find the path to the node.
+ */
+Node *Graph_findContainedNode( Node *node, int id )
+{
+    NodeList *nodes;
+
+    for ( nodes = node->interiorNodes; nodes != NULL; nodes = nodes->nextNode )
+    {
+        if ( nodes->node->id == id )
+            return( nodes->node );
+    }
+
+    return( NULL );
+}
+
+
+
+
+
+
+/* Search Algorithms */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/graphGen.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+/*
+ * graphGen.h
+ *
+ *  Created on: Aug 2, 2013
+ *      Author: J. Brian Rigdon
+ */
+
+#ifndef GRAPHGEN_H
+#define GRAPHGEN_H
+
+#include "graph.h"
+
+typedef enum { endNodesOnly, labeledNodes, completePath } BuildType;
+
+Graph *buildGraphFromPaths(NodeVecVec **pathList, BuildType build);
+
+/* Write the given graph to a file */
+bool exportGraph(Graph *graph, char *fileName);
+
+
+
+
+#endif /* GRAPHGEN_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/graphGen.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * graphGen.c
+ *
+ *  Created on: Aug 2, 2013
+ *      Author: jbrigdo
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include "graphGen.h"
+#include "vectorUtils.h"
+
+
+/* getDuplicateNodeForGraph takes a node from another graph and sees if
+ * a duplicate has previously been created for this graph. If not, it tries
+ * to create and insert a new duplicate. If that fails, we're out of memory.
+ * In that circumstance, we have a significant error condition. It is
+ * time to delete the graph being built and report that error to the
+ * calling method (buildGraphFromPaths).
+ */
+static Node *getDuplicateNodeForGraph(Graph *graph, Node *from)
+{
+    Node *newNode = Graph_findNode(graph, from->id, true); /* true == deep search */
+    if ( newNode )
+        return(newNode);
+
+    /* else */
+    newNode = Node_duplicate(from, graph->totalNodes++ ); /* POST increment */
+    if ( newNode )
+    {
+        Graph_addOuterNode(graph,newNode); /* all nodes are exterior in this graph */
+        newNode->type = exteriorNode;
+        return(newNode);
+    }
+
+    /* else */
+    Graph_delete(graph); /* Failure is DESTRUCTIVE at this point */
+    return NULL;
+}
+
+
+Graph *buildGraphFromPaths(NodeVecVec **pathList, BuildType build)
+{
+    Graph *newGraph = Graph_new();
+    Node *pathNode; /* The node we're looking at in the path */
+    Node *currentNode;
+    Node *nextNode;
+    int i; /* Iterator through the path List array */
+    int j; /* Iterator through each path List */
+    int k; /* Iterator through each path in the path List */
+
+    if ( !pathList || !newGraph )
+        return(NULL);
+
+    for ( i = 0; pathList[i] ; ++i )
+    {
+        for (j = 0; j < pathList[i]->contentSize; ++j)
+        {
+            pathNode = pathList[i]->vector[j]->vector[0];
+            currentNode = getDuplicateNodeForGraph(newGraph, pathNode);
+            if ( !currentNode )
+                return(NULL); /* out of memory: crashing! newGraph has already been cleaned up */
+
+            for ( k = 1; k < pathList[i]->vector[j]->contentSize; ++k /*also incremented below*/ )
+            {
+                if ( build == endNodesOnly )
+                {
+                    k = pathList[i]->vector[j]->contentSize - 1;
+                }
+                else if ( build == labeledNodes )
+                {
+                    while ( pathList[i]->vector[j]->vector[k]->labelIdx < 0 )
+                        ++k;
+                }
+                /* else if ( build == completePath ) no-op */
+
+                pathNode = pathList[i]->vector[j]->vector[k];
+                nextNode = getDuplicateNodeForGraph(newGraph, pathNode);
+                if ( !nextNode )
+                    return(NULL); /* out of memory: crashing! newGraph has already been cleaned up */
+                Node_addEdgeToNode(currentNode, nextNode);
+                // printf ( "Adding edge: %d ==> %d\n", currentNode->id, nextNode->id );
+                currentNode = nextNode;
+            }
+        }
+    }
+
+    return(newGraph);
+}
+
+
+/* Write the given graph to a file */
+bool exportGraph(Graph *graph, char *fileName)
+{
+    FILE *out = NULL;
+    NodeList *nodes = NULL;
+    EdgeList *edges = NULL;
+    int nodeCount = 0;
+
+    if ( !graph || !fileName ) /* A little basic error checking */
+        return(false);
+
+    out = fopen(fileName, "w");
+
+    if ( !out ) /* A little more basic error checking */
+        return(false);
+
+    /* Write out the header */
+    /* ... find out how many functions (outer nodes) the graph holds */
+    for ( nodes = graph->outerNodes; nodes != NULL; nodes = nodes->nextNode )
+    {
+        ++nodeCount;
+    }
+    fprintf(out, "Functions: %d\n", nodeCount);
+    fprintf(out, "Basic blocks: %d\n\n", graph->totalNodes);
+
+    /* First, write out the graph's outer nodes */
+    for ( nodes = graph->outerNodes; nodes != NULL; nodes = nodes->nextNode )
+    {
+        fprintf(out, "%d ", nodes->node->id);
+        //printf("Node: %d ", nodes->node->id);
+        if ( nodes->node->edges )
+        {
+            nodeCount = 0;
+            /* Wow is this inefficient, but two passes is the easiest way to do it. */
+            for ( edges = nodes->node->edges; edges != NULL; edges = edges->nextEdge )
+            {
+                if ( edges->targetNode->type == exteriorNode )
+                    ++nodeCount;
+            }
+            fprintf(out, "%d ", nodeCount);
+            //printf("has %d edges: ", nodeCount);
+            for ( edges = nodes->node->edges; edges != NULL; edges = edges->nextEdge )
+                {
+                    if ( edges->targetNode->type == exteriorNode )
+                    {
+                        fprintf(out, "%d ", edges->targetNodeId);
+                        //printf("%d, ", edges->targetNodeId);
+                    }
+                }
+            fprintf(out, "\n");
+            //printf("\n");
+        }
+        else
+        {
+            fprintf(out, "0 \n" );
+            //printf(" no edges.\n");
+        }
+    }
+
+    /* then, for each of the outer nodes, write out its interior nodes (if any) */
+    /* We are skipping this for the time being. This currently is being called with flat graphs. */
+
+    /* Finally, write out the labels. */
+    fprintf(out, "-------------------------------------------- \nSYSTEM CALLS \n\n");
+
+    for ( nodes = graph->outerNodes; nodes != NULL; nodes = nodes->nextNode )
+    {
+        if ( nodes->node->label != NULL )
+            fprintf(out, "%d %s \n", nodes->node->id, nodes->node->label );
+        /* If we were worried about interior nodes, we'd need a duplicate loop here. */
+    }
+
+    return(true);
+
+}

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/main.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * main.c
+ *
+ *  Created on: Jan 9, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <math.h>
+#include "parsing.h"
+#include "utils.h"
+#include "searchAlgorithms.h"
+#include "vectorUtils.h"
+#include "statistics.h"
+#include "configuration.h"
+
+#ifdef QT
+   #include "qThreadSearch.h"
+#endif /* QT */
+
+extern double currentTime();
+
+#define helpString "\nUsage: PathFinder.exe [OPTIONS] [<fileName>]\n\n\
+  Operation:\n\
+    -c  <config file>   use configuration file\n\
+    -i  <data file>     interactive search of specified data file\n\
+    -x  <data file>     exhaustive leg search (any label to any label) of data file\n\n\
+  Other:\n\
+    -o  <output file>   save optimized graph to file\n\
+    -h,u                prints this help message.\n\
+    -q  <depth>         use qthread parallelism (config file only). The depth value\n\
+                        specifies how deep in recursion to continue spawning new tasks\n\
+                        during searches\n\
+    -y                  create YAML output\n"
+
+/* Forward declarations so that main is the first function we read */
+void runBatch(char *configFile, Configuration *config);
+void runInteractively(char *fileName, Configuration *config);
+void exhaustiveLegSearch(char *fileName, Configuration *config);
+
+int main(int argc, char *argv[])
+{
+    char defaultFile[] = "MicroTestData.adj_list";
+    char *fileName = NULL;
+    Configuration *config = Configuration_new();
+    signed char c;
+    int cFlag = 0; // Why did I make these ints instead of bool? JBR - 10/25/13
+    int iFlag = 0;
+    int xFlag = 0;
+    int tFlag = 0;
+    int dFlag = 0;
+    int oFlag = 0;
+    bool qFlag = 0;
+    int qCount = 0;
+    char commandLine[200];
+    int i;
+
+        printf ( "\n\n"
+    "        PathFinder: finding a series of labeled nodes within a\n"
+    "                two-layer directed, cyclic graph.\n"
+    "               Copyright (2013) Sandia Corporation\n"
+    "\n"
+    " Sandia National Laboratories is a multi-program laboratory managed and\n"
+    " operated by Sandia Corporation, a wholly owned subsidiary of Lockheed\n"
+    " Martin Corporation, for the U.S. Department of Energy's National Nuclear\n"
+    " Security Administration under terms of Contract DE-AC04-94AL85000,\n"
+    " there is a non-exclusive license for use of this work by or on behalf\n"
+    " of the U.S. Government. Export of this program may require a license \n"
+    " from the United States Government.\n\n\n" );
+
+    #ifdef DEBUG
+        printf("\tRunning debug build\n\n");
+    #endif
+    #ifdef OPENMP
+        printf("\tRunning Open MP build\n\n");
+    #endif
+    #ifdef QT
+        printf("\tRunning Q Thread build\n\n");
+    #endif
+    
+    if ( !config )
+    {
+        printf("Error: Could not allocation configuration structure.\n\n\t---Exiting\n\n");
+        exit(0);
+    }
+
+    if ( argc < 2 )
+    {
+        exhaustiveLegSearch(defaultFile, config);
+    }
+    else
+    {
+        while ( (c = getopt(argc, argv, "c:i:x:o:q:huy")) != -1 )
+        {
+            switch (c)
+            {
+            case '?': /* we had a problem */
+                if ( optopt == 'c' )
+                    fprintf(stderr, "\tPlease specify configuration file.\n\n");
+                else if ( optopt == 'i' || optopt == 'x' )
+                    fprintf(stderr, "\tPlease specify data file.\n\n");
+                else if ( optopt == 'o' )
+                    fprintf(stderr, "\tPlease specify output graph data file.\n\n");
+                else if ( optopt == 'q' )
+                    fprintf(stderr, "\tPlease specify recursion depth to keep spawning tasks.\n\n");
+                return(1);
+                break; /* Superfluous, I know */
+            case 'h':
+            case 'u':
+                printf ("\n%s\n\n", helpString);
+                return(0); /* Nothing else matters */
+                break; /* Superfluous, I know. */
+            case 'c': /* configuration file */
+                fileName = optarg;
+                cFlag = 1;
+                break;
+            case 'i': /* interactive */
+                fileName = optarg;
+                iFlag = 1;
+                break;
+            case 'x': /* exhaustive leg search */
+                fileName = optarg;
+                xFlag = 1;
+                break;
+            case 'o': /* Save optimized paths in a new graph definition data file */
+                config->searchOptions->outputFile = optarg;
+                config->searchOptions->writeOutputFile = true;
+                oFlag = 1;
+                break;
+            case 's':
+                config->searchOptions->doStatistics = true;
+                break;
+            case 'q':
+                qCount = atoi(optarg);
+                if ( qCount < 1 ) 
+                    qCount =  1;
+                config->qThreadCount = qCount;
+                break;
+            case 'y':
+                if ( commandLine != NULL )
+                {
+                    YAMLOpen();
+                    commandLine[0] = '\0';
+                    for ( i = 0; i < argc; ++i )
+                        sprintf(commandLine, "%s %s", commandLine, argv[i] );
+                    YAMLWriteString("Command", commandLine+1);
+                }
+                break;
+            default :
+                break;
+            }
+        }
+
+        /* Debug --* /
+        if (cFlag) printf ("cFlag ");
+        if (iFlag) printf ("iFlag ");
+        if (xFlag) printf ("xFlag ");
+        if (oFlag) printf ("oFlag ");
+        if (fileName) printf ( " - %s", fileName );
+        if (outFile) printf ( " - %s", outFile);
+        printf ("\n");
+        / *-- End Debug */
+
+        if ( (cFlag+iFlag+xFlag) > 1 )
+        {
+            fprintf(stderr, "-c -i and -x are mutually exclusive, PathFinder can only do one of those.\n\n");
+            return(1);
+        }
+
+        if ( (cFlag+iFlag+xFlag) == 0 )
+        {
+            fprintf(stderr, "-c (config file) -i (interactive) or -x (exhaustive) must be specified.\n\n");
+            return(1);
+        }
+
+        if ( oFlag && !xFlag )
+        {
+            fprintf(stderr, "-o (optimized graph output) is only compatible with -x (exhaustive searches).\n\n");
+            return(1);
+        }
+
+        if ( cFlag )
+            runBatch(fileName, config);
+        else if ( iFlag )
+            runInteractively(fileName, config);
+        else
+        {
+            exhaustiveLegSearch(fileName, config);
+        }
+    }
+
+    YAMLClose(); /* works even if YAML logging isn't present */
+    return(0); /* zero means no error */
+}
+
+void runBatch(char *configFile, Configuration *config)
+{
+    bool success;
+    int i;
+    int j;
+    double tick, tock;
+    int hours;
+    int min;
+    double sec;
+    
+    if ( !configFile )
+    {
+        printf("Error: No config file entered.\n\n\t---Exiting---");
+        exit(0);
+    }
+
+    // printf("config file: %s\n", configFile);
+
+    tick = currentTime();
+    success = parseConfigFile(configFile, config);
+    tock = currentTime();
+    sec = tock-tick;
+    hours = (int)sec/3600;
+    sec = fmod( sec, 3600.0 );
+    min = (int)sec/60;
+    sec = fmod(sec, 60.0);
+    printf ("\n\nOverall Parse Time: %02d:%02d:%02.3f\n", hours, min, sec);
+
+    /* Debug --* /
+    for ( i = 0; config->signatures[i] != NULL; ++i );
+    for ( j = 0; config->graphs[j] != NULL; ++j );
+    printf( "%d files, %d signatures \n", j, i ); 
+    exit(1);
+    / *-- End Debug */
+
+    if ( success )
+    {
+    #ifdef QT
+        doMultiSearchesQT(config);
+    #else
+        doMultiSearches(config);
+    #endif
+    }
+
+    printf ("\n\nSearches complete.\n");
+}
+
+
+void runInteractively(char *fileName, Configuration *config)
+{
+    char stringBuffer[200];
+    Graph *graph;
+    char *labels[25]; /* Do we need an interactive signature bigger than 25? */
+    NodePtrVec *path = NULL;
+    bool success = false;
+    int i, j;
+    int fullIntSignature[3] = { 0, 0, -1 };
+    
+
+    graph = parseFile(fileName);
+
+    if ( !graph )
+        return;
+
+    while ( 1 )
+    {
+        i = 0;
+        do {
+
+            printf("\nPlease insert a node label for this signature (\"\" to complete, \"bail\" to exit):\n");
+            gets(stringBuffer);
+
+            if ( strcmp (stringBuffer, "bail") == 0 )
+                exit(1);
+
+            if ( strcmp(stringBuffer, "") != 0 )
+            {
+                labels[i] = strdup(stringBuffer);
+                ++i;
+            }
+
+        } while ( i < 25 && strcmp(stringBuffer, "") != 0 );
+
+        labels[i] = NULL;
+
+        /* Debug */
+        printf("\nSignature: ");
+        for ( j = 0; j < i; ++j )
+        {
+            printf("'%s'", labels[j]);
+            if ( j < i-1 )
+                printf(" -> ");
+            else
+                printf("\n\n");
+        }
+        /* end debug */
+
+        path = NodePtrVec_new(50);
+        success = findLabelPath(graph, (Signature)labels, path, config->searchOptions->searchType);
+
+        /* Sanity check to verify that a valid path exists */
+        if( success )
+        {
+            /* printStack ( path ); */
+            printf ("Found, resultant path has %d steps.\n", path->contentSize);
+        }
+        else
+            printf("\n\tPath not found for signature.\n");
+
+        NodePtrVec_delete(path);
+    }
+
+}
+
+void exhaustiveLegSearch(char *fileName, Configuration *config)
+{
+    Graph *graph;
+    int found;
+
+    graph = parseFile(fileName);
+
+    if ( !graph || !config )
+        return;
+
+    if ( config->searchOptions->outputFile == NULL )
+        found = findAllPossibleLegs(graph, config->searchOptions->searchType);
+    else
+        found = findAndLogAllPossibleLegs(graph, config->searchOptions);
+    printf("\n\nTotal %d legs found\n\n", found);
+    Graph_delete(graph);
+}

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/medsmall1.adj_list

+Functions: 500
+Basic blocks: 3463
+
+0 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+300000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 37500000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 33700000 
[phone] 
[phone] 1700000 6600000 41500000 27400000 23500000 37800000 5500000 14800000 42700000 10100000 36500000 12700000 25200000 31000000 26900000 32700000 28200000 6300000 29300000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+600000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 29100000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 40800000 
[phone] 
[phone] 
[phone] 15400000 
+900000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 30900000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+100000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 34600000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+400000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 8100000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 1300000 
[phone] 
[phone] 
+700000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 31600000 
[phone] 
[phone] 
[phone] 48400000 17800000 29100000 10700000 36800000 15100000 30200000 10400000 2200000 18400000 26600000 35900000 32400000 41700000 12600000 9100000 2100000 14900000 46900000 900000 23000000 9000000 7800000 17100000 48500000 5400000 37100000 24000000 17000000 13500000 10000000 21600000 30900000 36200000 10500000 46000000 600000 40900000 34300000 2900000 21500000 43600000 27300000 45900000 49800000 28400000 34200000 49300000 30500000 13200000 35300000 6200000 28300000 34100000 1500000 37500000 22700000 4900000 36300000 45600000 43700000 33800000 22300000 44400000 5900000 46700000 47200000 18800000 4600000 35000000 31500000 40800000 37300000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 32000000 25600000 14000000 37200000 9200000 46400000 48700000 16100000 30100000 4400000 39300000 6700000 41600000 27600000 11300000 15900000 18200000 20500000 39100000 41400000 25100000 5800000 3900000 29700000 13400000 36700000 15700000 18000000 20300000 38900000 43500000 27200000 48100000 31800000 15500000 40700000 24700000 8400000 43400000 31600000 15300000 1300000 3600000 22200000 38800000 15000000 45400000 31400000 33700000 36000000 19700000 22000000 5700000 28900000 36900000 33500000 17200000 35800000 3200000 45000000 47300000 700000 35600000 5300000 46200000 26100000 42500000 47100000 33100000 35400000 19100000 2800000 5000000 42300000 26000000 9700000 26700000 14300000 16600000 300000 18900000 21200000 43100000 25800000 23900000 100000 2400000 26400000 24400000 27900000 11600000 16200000 34800000 18500000 20800000 23100000 6800000 1800000 21300000 7400000 30000000 34600000 18300000 2000000 8900000 43800000 27500000 32100000 15800000 34400000 3400000 7500000 6400000 11000000 13300000 31900000 15600000 17900000 20200000 41100000 24800000 35100000 27100000 45700000 13100000 31700000 34000000 17700000 3700000 24600000 43200000 10600000 29200000 1200000 30600000 3500000 43000000 45300000 47600000 31300000 49900000 33600000 49500000 3300000 21900000 48900000 12500000 19400000 21700000 26300000 26200000 26500000 16900000 19200000 5200000 42400000 44700000 14400000 16700000 400000 48300000 7300000 25900000 44500000 46800000 49100000 21100000 23400000 11700000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+200000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 26200000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+500000 0 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 17600000 21000000 3800000 48000000 47700000 39800000 28700000 38000000 37700000 34500000 1600000 39400000 22500000 9400000 11100000 37600000 
[phone] 16400000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+800000 0 
[phone] 31200000 32600000 18600000 2300000 39500000 23200000 6900000 44100000 27800000 34700000 28500000 1900000 6500000 8800000 42600000 20700000 17500000 36600000 22600000 10900000 29500000 11900000 20100000 22400000 41000000 43300000 27000000 13000000 24200000 14600000 33900000 19900000 38500000 19600000 48600000 17400000 1100000 42900000 47500000 49700000 19500000 38100000 40400000 14700000 33300000 3000000 37900000 33400000 34900000 7600000 9900000 44800000 30800000 49400000 16800000 500000 21400000 5100000 12000000 12300000 49200000 32900000 35200000 47900000 4700000 11800000 16400000 18700000 13600000 36400000 41900000 46500000 48800000 40200000 11400000 44000000 40500000 16000000 20600000 46100000 29800000 9800000 32300000 20400000 39000000 41300000 29600000 30300000 29400000 15400000 20000000 6000000 8300000 10800000 21800000 36100000 19800000 38400000 22100000 17300000 38200000 5600000 23300000 42800000 10200000 47400000 800000 7000000 28100000 33200000 46600000 37000000 8200000 23800000 47000000 33000000 19000000 2700000 16300000 23600000 42200000 14200000 32800000 2500000 37400000 4800000 39700000 7100000 42000000 25700000 44300000 
[phone] 42700000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 42600000 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 12800000 8000000 41800000 13800000 9300000 25300000 29900000 32200000 4200000 22800000 44200000 10300000 4000000 8600000 45800000 43900000 38700000 6100000 24500000 45200000 25400000 38300000 24300000 20900000 24100000 12400000 49600000 19300000 28600000 4500000 12200000 14500000 40000000 23700000 44600000 13900000 2600000 7200000 42100000 9500000 30400000 14100000 49000000 39200000 41200000 39600000 27700000 32500000 46300000 4300000 22900000 11200000 18100000 29000000 45100000 4100000 25000000 8700000 48200000 8500000 25500000 1400000 38600000 45500000 47800000 15200000 26800000 1000000 24900000 7900000 28800000 31100000 35700000 40300000 7700000 44900000 40600000 13700000 35500000 40100000 12100000 30700000 11500000 39900000 9600000 16500000 200000 28000000 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
+0
+0 2 0 1 
+1 1 2 
+2 1 3 
+3 1 4 
+4 1 5 
+5 1 4 
+
+--------------------------------------------
[phone]
[phone] 32000001 
[phone] 32000001 32000002 
[phone] 32000003 
[phone] 32000004 
[phone] 32000005 
[phone] 32000002 32000006 
[phone] 32000007 
[phone] 32000008 
[phone] 32000009 32000006 
[phone] 32000010 32000003 
[phone] 32000011 
[phone] 32000009 32000012 
[phone] 32000008 32000013 
[phone] 32000001 32000014 
[phone] 32000010 
+
+--------------------------------------------
[phone]
[phone] 34900001 
[phone] 34900002 
[phone] 34900003 
[phone] 34900004 
[phone] 
+
+--------------------------------------------
+4600000
[phone] 
[phone] 
[phone] 4600003 
[phone] 4600004 
[phone] 
[phone] 4600006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 39500001 
[phone] 39500002 
[phone] 39500003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44100001 44100002 
[phone] 44100002 
[phone] 44100000 
+
+--------------------------------------------
[phone]
[phone] 15700001 
[phone] 
+
+--------------------------------------------
+1900000
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
+6500000
[phone] 6500001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 18600000 18600001 
[phone] 18600002 
[phone] 18600003 
[phone] 18600001 18600004 
[phone] 18600005 
[phone] 18600006 
[phone] 18600007 
[phone] 18600001 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+2300000
[phone] 
+
+--------------------------------------------
+8400000
[phone] 8400001 
[phone] 8400004 
[phone] 8400003 
[phone] 8400004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 13000001 
[phone] 13000000 13000002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 22200001 
[phone] 22200001 22200002 
[phone] 22200003 
[phone] 22200003 22200004 
[phone] 22200003 22200005 
[phone] 22200006 
[phone] 22200000 22200007 
[phone] 22200006 
+
+--------------------------------------------
[phone]
[phone] 37200000 
+
+--------------------------------------------
[phone]
[phone] 12600001 
[phone] 12600002 12600010 
[phone] 12600003 
[phone] 12600004 
[phone] 12600002 12600005 
[phone] 12600000 12600006 
[phone] 12600007 
[phone] 12600008 
[phone] 12600009 12600004 
[phone] 12600010 12600005 
[phone] 12600009 12600011 
[phone] 12600012 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+1100000
[phone] 1100003 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 1100007 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36000000 
+
+--------------------------------------------
[phone]
[phone] 40600000 40600001 
[phone] 40600001 
+
+--------------------------------------------
[phone]
[phone] 10300000 10300001 
[phone] 10300002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45200001 
[phone] 45200002 
[phone] 45200003 45200004 
[phone] 45200004 
[phone] 45200005 
[phone] 45200006 45200007 
[phone] 45200007 
[phone] 45200008 45200005 
[phone] 
+
+--------------------------------------------
+1700000
[phone] 1700005 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 1700002 
[phone] 1700004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 19500001 
[phone] 19500001 19500002 
[phone] 19500003 
[phone] 19500004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 24100001 
[phone] 24100002 
[phone] 24100003 24100007 
[phone] 24100004 
[phone] 24100003 24100005 
[phone] 24100000 24100006 
[phone] 24100001 24100007 
[phone] 24100008 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 28700001 
[phone] 
+
+--------------------------------------------
+3000000
[phone] 
[phone] 
[phone] 3000004 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37900001 
[phone] 37900002 
[phone] 37900002 37900003 
[phone] 37900000 37900004 
[phone] 37900002 
+
+--------------------------------------------
[phone]
[phone] 36600001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 25300000 25300001 
[phone] 25300000 
+
+--------------------------------------------
+7600000
[phone] 
[phone] 7600005 
[phone] 
[phone] 7600004 
[phone] 7600005 
[phone] 7600006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 12200001 
[phone] 12200002 
[phone] 12200000 
+
+--------------------------------------------
[phone]
[phone] 47100001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 16800001 
[phone] 16800000 16800002 
[phone] 16800003 
[phone] 16800004 
[phone] 16800001 16800005 
[phone] 16800006 
[phone] 16800007 
[phone] 16800008 
[phone] 16800009 
[phone] 16800010 
[phone] 16800001 
+
+--------------------------------------------
[phone]
[phone] 21400001 21400003 
[phone] 21400002 
[phone] 21400003 
[phone] 21400004 21400005 
[phone] 21400004 21400005 
[phone] 21400000 
+
+--------------------------------------------
[phone]
[phone] 26000001 
[phone] 26000002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 20300000 
+
+--------------------------------------------
+300000
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 35200001 
[phone] 
+
+--------------------------------------------
+4900000
[phone] 4900001 
[phone] 4900002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 39800000 
+
+--------------------------------------------
+9500000
[phone] 
[phone] 
[phone] 9500003 
[phone] 9500004 
[phone] 9500005 
[phone] 9500006 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 9500011 
[phone] 9500013 
[phone] 
[phone] 9500014 
[phone] 9500015 
[phone] 9500012 
[phone] 9500006 
[phone] 9500010 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44400000 44400001 
[phone] 44400002 
[phone] 44400003 
[phone] 44400004 
[phone] 44400001 44400005 
[phone] 44400006 
[phone] 
+
+--------------------------------------------
+4700000
[phone] 
[phone] 4700002 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 14100000 14100001 
[phone] 14100002 14100003 
[phone] 14100003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 18700000 18700001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 41200001 
[phone] 41200002 
[phone] 41200002 
+
+--------------------------------------------
[phone]
[phone] 23300001 
[phone] 23300002 
[phone] 23300003 23300005 
[phone] 23300009 23300004 
[phone] 23300005 
[phone] 23300003 23300006 
[phone] 23300016 23300007 
[phone] 23300008 
[phone] 23300009 23300002 
[phone] 23300010 
[phone] 23300010 23300011 
[phone] 23300012 
[phone] 23300013 23300006 
[phone] 23300014 
[phone] 23300015 
[phone] 23300016 23300011 
[phone] 23300004 
+
+--------------------------------------------
[phone]
[phone] 27900001 27900002 
[phone] 27900002 
[phone] 27900001 27900003 
[phone] 27900002 27900004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 32500001 
[phone] 32500002 
[phone] 32500003 
[phone] 32500002 32500004 
[phone] 32500001 
+
+--------------------------------------------
+2200000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37100000 37100001 
[phone] 37100002 37100007 
[phone] 37100003 
[phone] 37100004 
[phone] 37100001 37100005 
[phone] 37100006 
[phone] 37100007 
[phone] 37100000 
+
+--------------------------------------------
[phone]
[phone] 49800001 
[phone] 49800000 49800002 
[phone] 49800003 
[phone] 49800004 
[phone] 49800005 
[phone] 49800006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 40200000 
+
+--------------------------------------------
[phone]
[phone] 41700001 41700002 
[phone] 41700001 41700002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 21000000 
+
+--------------------------------------------
[phone]
[phone] 11400001 
[phone] 11400002 11400005 
[phone] 11400000 11400003 
[phone] 11400004 
[phone] 11400003 11400005 
[phone] 11400001 11400006 
[phone] 11400007 
[phone] 11400008 
[phone] 11400001 
+
+--------------------------------------------
+1800000
[phone] 1800005 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 1800006 
[phone] 1800007 
[phone] 
+
+--------------------------------------------
+6900000
[phone] 
[phone] 
[phone] 6900007 
[phone] 6900004 
[phone] 6900005 
[phone] 
[phone] 
[phone] 
[phone] 6900009 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 46300001 
[phone] 46300001 46300002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 16000001 
[phone] 16000002 16000010 
[phone] 16000003 
[phone] 16000004 
[phone] 16000010 16000005 
[phone] 16000006 
[phone] 16000003 16000007 
[phone] 16000008 16000006 
[phone] 16000009 
[phone] 16000010 
[phone] 16000011 
[phone] 16000012 
[phone] 16000005 
+
+--------------------------------------------
[phone]
[phone] 20600001 
[phone] 20600002 20600006 
[phone] 20600000 20600003 
[phone] 20600004 
[phone] 20600005 
[phone] 20600006 
[phone] 20600007 
[phone] 20600008 
[phone] 20600009 
[phone] 20600010 20600004 
[phone] 20600011 
[phone] 20600012 
[phone] 20600001 20600013 
[phone] 20600013 20600014 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 30600001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 25200001 
[phone] 25200002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 29800001 
[phone] 29800002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 41800001 
[phone] 41800001 41800002 
[phone] 41800000 41800003 
[phone] 
+
+--------------------------------------------
+9100000
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
+4100000
[phone] 
[phone] 
[phone] 4100003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 43600000 43600001 
[phone] 43600002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 48200001 
[phone] 48200000 
+
+--------------------------------------------
[phone]
[phone] 17900001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 22500001 22500006 
[phone] 22500002 
[phone] 22500003 
[phone] 22500004 
[phone] 22500005 
[phone] 22500006 
[phone] 22500006 
+
+--------------------------------------------
+6300000
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 27100000 27100001 
[phone] 
+
+--------------------------------------------
+1400000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36300001 
[phone] 36300002 36300006 
[phone] 36300003 
[phone] 36300004 
[phone] 36300002 36300005 
[phone] 36300006 
[phone] 36300004 
+
+--------------------------------------------
+6000000
[phone] 
[phone] 
[phone] 37500000 
+
+--------------------------------------------
[phone]
[phone] 40900000 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45500001 
[phone] 45500002 
[phone] 45500000 45500003 
[phone] 45500004 
[phone] 45500003 45500005 
[phone] 45500006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 15200001 
[phone] 15200002 
[phone] 15200003 
[phone] 15200004 
[phone] 15200003 15200005 
[phone] 15200001 
+
+--------------------------------------------
+9200000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 31400001 
[phone] 31400002 
[phone] 31400003 
[phone] 31400004 
[phone] 31400002 31400005 
[phone] 31400006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 24400001 24400003 
[phone] 24400002 
[phone] 24400003 
[phone] 24400003 24400004 
[phone] 24400003 
+
+--------------------------------------------
[phone]
[phone] 29000000 
+
+--------------------------------------------
[phone]
[phone] 33600001 
[phone] 33600001 
+
+--------------------------------------------
+3300000
[phone] 
[phone] 
[phone] 
[phone] 3300004 
[phone] 3300005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 38200001 
[phone] 38200002 38200003 
[phone] 38200003 
[phone] 38200004 
[phone] 38200005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 24900001 
[phone] 24900002 
[phone] 24900003 
[phone] 24900002 24900004 
[phone] 24900005 
[phone] 24900006 
[phone] 24900007 
[phone] 24900008 
[phone] 24900009 24900006 
[phone] 24900010 
[phone] 24900011 24900005 
[phone] 24900001 
+
+--------------------------------------------
+7900000
[phone] 
[phone] 
[phone] 
[phone] 7900004 
[phone] 
[phone] 
[phone] 7900007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42800001 
[phone] 42800002 
[phone] 42800000 42800003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 12500001 
[phone] 12500002 
[phone] 12500003 
[phone] 12500003 12500004 
[phone] 12500004 12500005 
[phone] 12500004 12500006 
[phone] 12500006 12500007 
[phone] 12500008 12500006 
[phone] 12500007 33700000 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 17100033 17100028 
[phone] 17100033 17100034 
[phone] 17100035 14800000 
[phone] 17100028 17100036 
[phone] 17100037 41500000 
[phone] 17100038 42700000 
[phone] 17100035 17100039 
[phone] 17100040 1700000 
[phone] 17100041 6600000 
[phone] 17100042 36500000 
[phone] 17100043 28200000 
[phone] 27400000 
[phone] 17100001 10100000 
[phone] 17100002 31000000 
[phone] 17100003 17100030 
[phone] 17100043 17100004 
[phone] 17100005 5500000 
[phone] 17100006 17100031 
[phone] 17100011 17100007 
[phone] 17100008 
[phone] 17100009 17100001 
[phone] 17100010 
[phone] 17100011 26900000 
[phone] 17100012 25200000 
[phone] 17100009 17100013 
[phone] 17100014 17100007 
[phone] 17100015 37800000 
[phone] 17100016 12700000 
[phone] 17100017 23500000 
[phone] 17100018 17100037 
[phone] 17100019 29300000 
[phone] 17100020 6300000 
[phone] 17100003 17100021 
[phone] 17100022 
[phone] 17100020 17100023 
[phone] 17100024 17100041 
[phone] 17100025 17100020 
[phone] 17100026 17100023 
[phone] 17100010 17100027 
[phone] 17100028 32700000 
[phone] 17100029 17100022 
[phone] 17100014 17100030 
[phone] 17100034 17100031 
[phone] 17100032 17100023 
+
+--------------------------------------------
[phone]
[phone] 21700001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 26300001 
[phone] 26300002 
[phone] 26300003 
[phone] 26300002 26300004 
[phone] 26300005 
[phone] 26300006 
[phone] 26300007 
[phone] 26300008 26300007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 27800000 
+
+--------------------------------------------
+5700000
[phone] 
[phone] 5700007 
[phone] 
[phone] 
[phone] 
[phone] 5700006 
[phone] 5700007 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
+600000
[phone] 
[phone] 600002 
+600002 0 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+5200000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 40100000 
+
+--------------------------------------------
+9800000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44700000 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 49300001 49300003 
[phone] 49300002 
[phone] 49300002 49300003 
[phone] 49300003 49300004 
[phone] 49300002 49300005 
[phone] 49300001 
+
+--------------------------------------------
[phone]
[phone] 19000001 
[phone] 19000002 
[phone] 19000003 
[phone] 19000004 
[phone] 19000005 
[phone] 19000003 19000006 
[phone] 19000007 
[phone] 19000008 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 11500000 11500001 
[phone] 11500002 
[phone] 11500003 
[phone] 11500001 
+
+--------------------------------------------
[phone]
[phone] 23600000 23600001 
[phone] 23600002 
[phone] 23600002 
+
+--------------------------------------------
[phone]
[phone] 28200001 
[phone] 28200002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 32800001 
[phone] 
+
+--------------------------------------------
+2500000
[phone] 
[phone] 
[phone] 
[phone] 2500004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37400000 
+
+--------------------------------------------
+7100000
[phone] 
[phone] 7100002 
[phone] 7100003 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42000001 
[phone] 42000002 
[phone] 42000003 
[phone] 42000003 42000004 
[phone] 42000005 42000007 
[phone] 42000008 42000006 
[phone] 42000005 42000007 
[phone] 42000008 
[phone] 42000009 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 11700001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 46400001 
[phone] 46400001 
+
+--------------------------------------------
[phone]
[phone] 31200001 
[phone] 31200002 
[phone] 31200000 31200003 
[phone] 31200004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 16300001 16300010 
[phone] 16300002 
[phone] 16300003 
[phone] 16300004 
[phone] 16300000 16300005 
[phone] 16300012 16300006 
[phone] 16300007 
[phone] 16300008 16300000 
[phone] 16300009 16300005 
[phone] 16300010 
[phone] 16300011 
[phone] 16300012 
[phone] 16300000 16300013 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 20900001 
[phone] 20900002 
[phone] 20900003 
[phone] 20900003 20900004 
[phone] 20900001 
+
+--------------------------------------------
[phone]
[phone] 25500001 
[phone] 25500008 25500002 
[phone] 25500003 
[phone] 25500000 25500004 
[phone] 25500002 25500005 
[phone] 25500006 
[phone] 25500003 25500007 
[phone] 25500008 25500004 
[phone] 25500009 
[phone] 25500010 25500003 
[phone] 25500010 
+
+--------------------------------------------
[phone]
[phone] 30100000 30100001 
[phone] 30100002 
[phone] 30100003 
[phone] 30100004 
[phone] 30100005 
[phone] 30100005 30100006 
[phone] 30100007 
[phone] 30100001 
+
+--------------------------------------------
[phone]
[phone] 18200001 18200002 
[phone] 18200002 18200003 
[phone] 18200000 18200003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 22800000 22800001 
[phone] 22800002 
[phone] 22800001 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+8700000
[phone] 8700001 
[phone] 8700002 
[phone] 8700013 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 8700006 
[phone] 8700013 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 48700000 48700001 
[phone] 48700001 48700002 
[phone] 48700003 
[phone] 48700001 48700004 
[phone] 48700005 
[phone] 48700004 48700006 
[phone] 48700005 
+
+--------------------------------------------
[phone]
[phone] 24700001 
[phone] 24700001 24700002 
[phone] 24700000 
+
+--------------------------------------------
[phone]
[phone] 32400001 
[phone] 
+
+--------------------------------------------
+8600000
[phone] 
[phone] 
[phone] 
[phone] 8600004 
[phone] 40800000 
+
+--------------------------------------------
[phone]
[phone] 12800000 12800001 
[phone] 12800002 
[phone] 12800002 12800003 
[phone] 12800004 
[phone] 12800005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 22000000 22000001 
[phone] 22000001 22000002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 26600001 
[phone] 26600001 26600002 
[phone] 26600002 
+
+--------------------------------------------
[phone]
[phone] 16100001 
[phone] 16100002 15400000 
[phone] 16100003 
[phone] 16100004 
[phone] 16100000 
+
+--------------------------------------------
+900000
+900000 0 
+
+--------------------------------------------
[phone]
[phone] 35800000 
+
+--------------------------------------------
+5500000
[phone] 
[phone] 
[phone] 
[phone] 5500004 
[phone] 
[phone] 5500006 
[phone] 
[phone] 5500007 
[phone] 
[phone] 
[phone] 
[phone] 5500007 
[phone] 5500013 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 40400001 
[phone] 40400002 40400004 
[phone] 40400003 40400011 
[phone] 40400012 40400004 
[phone] 40400011 40400005 
[phone] 40400006 
[phone] 40400011 40400007 
[phone] 40400008 
[phone] 40400009 
[phone] 40400010 40400003 
[phone] 40400011 
[phone] 40400000 40400012 
[phone] 40400009 40400013 
[phone] 40400013 40400014 
[phone] 40400008 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45000001 45000004 
[phone] 45000002 
[phone] 45000003 
[phone] 45000004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 49600001 49600004 
[phone] 49600002 
[phone] 49600001 49600003 
[phone] 49600004 
[phone] 49600002 49600005 
[phone] 49600006 
[phone] 49600007 
[phone] 49600008 
[phone] 49600009 49600003 
[phone] 49600010 49600003 
[phone] 49600002 49600011 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 31800000 
+
+--------------------------------------------
[phone]
[phone] 14900001 
[phone] 30900000 
+
+--------------------------------------------
[phone]
[phone] 28500001 28500007 
[phone] 28500009 28500002 
[phone] 28500003 
[phone] 28500004 
[phone] 28500005 
[phone] 28500001 28500006 
[phone] 28500007 
[phone] 28500008 28500007 
[phone] 28500009 28500006 
[phone] 28500010 
[phone] 28500011 
[phone] 28500012 
[phone] 28500008 28500013 
[phone] 28500014 
[phone] 28500015 
[phone] 28500004 
+
+--------------------------------------------
[phone]
[phone] 33100000 33100001 
[phone] 33100002 
[phone] 
+
+--------------------------------------------
+2800000
[phone] 2800001 
[phone] 2800002 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37700001 
[phone] 37700002 
[phone] 37700001 37700003 
[phone] 37700004 
[phone] 37700003 37700005 
[phone] 37700001 37700006 
[phone] 37700002 37700007 
[phone] 37700008 
[phone] 37700009 37700002 
[phone] 
+
+--------------------------------------------
+7400000
[phone] 
[phone] 7400003 
[phone] 7400003 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42300001 42300002 
[phone] 42300000 42300002 
[phone] 42300003 
[phone] 42300001 
+
+--------------------------------------------
[phone]
[phone] 12000000 12000001 
[phone] 12000002 
[phone] 12000001 12000003 
[phone] 12000004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 34700000 34700001 
[phone] 34700001 
+
+--------------------------------------------
[phone]
[phone] 16600001 
[phone] 16600002 
[phone] 16600001 16600003 
[phone] 16600004 
[phone] 16600005 
[phone] 16600000 16600006 
[phone] 16600004 
+
+--------------------------------------------
[phone]
[phone] 21200001 
[phone] 21200002 
[phone] 21200003 
[phone] 21200004 
[phone] 21200005 
[phone] 21200001 21200006 
[phone] 21200007 
[phone] 21200008 
[phone] 21200009 
[phone] 21200010 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 25800001 
[phone] 25800000 25800002 
[phone] 25800003 
[phone] 25800004 
[phone] 25800005 
[phone] 25800006 
[phone] 25800002 25800007 
[phone] 25800008 
[phone] 25800009 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 30400000 30400001 
[phone] 
+
+--------------------------------------------
+100000
[phone] 
[phone] 
[phone] 
[phone] 100004 
[phone] 
+100005 0 
+
+--------------------------------------------
[phone]
[phone] 35000000 
+
+--------------------------------------------
[phone]
[phone] 18400001 18400006 
[phone] 18400002 
[phone] 18400003 
[phone] 18400004 
[phone] 18400005 
[phone] 18400006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 18000001 
[phone] 18000000 
+
+--------------------------------------------
[phone]
[phone] 39600001 
[phone] 39600000 
+
+--------------------------------------------
+9300000
[phone] 
[phone] 
[phone] 
[phone] 9300004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44200000 44200001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 13900001 
[phone] 13900001 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 18500001 18500005 
[phone] 18500002 18500004 
[phone] 18500003 18500005 
[phone] 18500004 
[phone] 18500005 
[phone] 18500005 
+
+--------------------------------------------
[phone]
[phone] 23100001 23100003 
[phone] 23100002 23100004 
[phone] 23100003 
[phone] 23100002 23100004 
[phone] 23100005 
[phone] 23100006 
[phone] 23100003 23100007 
[phone] 23100008 23100006 
[phone] 23100009 
[phone] 23100010 23100003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 27700001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 34100001 
[phone] 34100000 34100002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+2000000
[phone] 
[phone] 2000002 
[phone] 2000006 
[phone] 
[phone] 
[phone] 2000006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36900001 
[phone] 36900000 
+
+--------------------------------------------
+6600000
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 11200000 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+5000000
[phone] 5000015 
[phone] 5000002 
[phone] 5000003 
[phone] 
[phone] 5000005 
[phone] 
[phone] 
[phone] 5000004 
[phone] 
[phone] 5000018 
[phone] 
[phone] 5000012 
[phone] 
[phone] 
[phone] 
[phone] 5000013 
[phone] 
[phone] 5000018 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 14700001 
[phone] 14700002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 20400001 
[phone] 20400001 
+
+--------------------------------------------
[phone]
[phone] 25000001 25000003 
[phone] 25000002 
[phone] 25000003 
[phone] 25000001 25000004 
[phone] 25000002 
+
+--------------------------------------------
[phone]
[phone] 29600001 
[phone] 29600000 
+
+--------------------------------------------
[phone]
[phone] 34200001 
[phone] 34200002 
[phone] 34200003 
[phone] 34200003 
+
+--------------------------------------------
+3900000
[phone] 
[phone] 
[phone] 3900003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 38800001 
[phone] 38800009 38800002 
[phone] 38800003 
[phone] 38800001 38800004 
[phone] 38800010 38800005 
[phone] 38800006 
[phone] 38800006 38800007 
[phone] 38800008 
[phone] 38800000 38800009 
[phone] 38800010 
[phone] 
+
+--------------------------------------------
+8500000
[phone] 
[phone] 8500002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 20700001 
[phone] 20700000 20700002 
[phone] 20700003 
[phone] 20700001 
+
+--------------------------------------------
[phone]
[phone] 13100001 
[phone] 13100001 13100002 
[phone] 13100003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 48000001 
[phone] 48000001 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 26900000 26900001 
[phone] 26900000 26900002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 31500001 31500004 
[phone] 31500002 
[phone] 31500003 31500006 
[phone] 31500001 31500004 
[phone] 31500005 
[phone] 31500000 31500006 
[phone] 
+
+--------------------------------------------
+4400000
[phone] 4400001 
[phone] 29100000 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37000000 
+
+--------------------------------------------
+1200000
[phone] 1200001 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36100001 
[phone] 36100002 
[phone] 36100003 
[phone] 36100004 
[phone] 36100005 
[phone] 36100003 36100006 
[phone] 36100007 
[phone] 
+
+--------------------------------------------
+5800000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 40700001 
[phone] 40700002 
[phone] 40700003 
[phone] 40700000 40700004 
[phone] 40700000 
+
+--------------------------------------------
[phone]
[phone] 10400001 
[phone] 10400002 
[phone] 10400003 
[phone] 10400004 10400015 
[phone] 10400005 
[phone] 10400006 
[phone] 10400005 10400007 
[phone] 10400008 
[phone] 10400009 
[phone] 10400010 
[phone] 10400011 
[phone] 10400003 10400012 
[phone] 10400003 10400013 
[phone] 10400014 
[phone] 10400000 10400015 
[phone] 10400016 
[phone] 10400017 
[phone] 10400018 10400004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45300001 45300004 
[phone] 45300002 
[phone] 45300003 
[phone] 45300003 45300004 
[phone] 45300017 45300005 
[phone] 45300003 45300006 
[phone] 45300002 45300007 
[phone] 45300008 45300005 
[phone] 45300009 45300001 
[phone] 45300001 45300010 
[phone] 45300008 45300011 
[phone] 45300012 
[phone] 45300001 45300013 
[phone] 45300014 
[phone] 45300002 45300015 
[phone] 45300016 
[phone] 45300017 45300003 
[phone] 45300018 
[phone] 45300003 
+
+--------------------------------------------
[phone]
[phone] 15000001 
[phone] 15000002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 49900001 
[phone] 49900000 
+
+--------------------------------------------
[phone]
[phone] 49500001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 19600001 
[phone] 19600002 
[phone] 19600003 
[phone] 19600004 
[phone] 19600005 
[phone] 19600001 19600006 
[phone] 19600002 19600007 
[phone] 19600008 19600012 
[phone] 19600009 
[phone] 19600010 19600013 
[phone] 19600011 
[phone] 19600012 
[phone] 19600013 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 30300001 
[phone] 30300000 
+
+--------------------------------------------
[phone]
[phone] 11100000 
+
+--------------------------------------------
[phone]
[phone] 39300001 
[phone] 39300002 
[phone] 39300001 39300003 
[phone] 39300004 
[phone] 39300005 
[phone] 39300003 39300006 
[phone] 39300004 39300007 
[phone] 39300008 
[phone] 39300009 
[phone] 39300010 
[phone] 39300011 
[phone] 39300008 39300012 
[phone] 39300013 
[phone] 39300014 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 28800001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 33400008 33400001 
[phone] 33400002 
[phone] 33400003 
[phone] 33400008 33400004 
[phone] 33400005 
[phone] 33400003 33400006 
[phone] 33400007 
[phone] 33400008 
[phone] 
+
+--------------------------------------------
+3100000
[phone] 34600000 
[phone] 3100002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 38000001 
[phone] 38000002 
[phone] 38000003 
[phone] 38000004 
[phone] 38000005 
[phone] 38000006 
[phone] 38000007 
[phone] 38000003 
+
+--------------------------------------------
+7700000
[phone] 7700001 
[phone] 
[phone] 7700003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42600008 42600001 
[phone] 42600002 
[phone] 42600000 42600003 
[phone] 42600004 
[phone] 42600005 
[phone] 42600001 42600006 
[phone] 42600005 42600007 
[phone] 42600008 
[phone] 42600000 42600009 
[phone] 42600009 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 47200000 47200001 
[phone] 47200002 
[phone] 47200003 
[phone] 47200004 
[phone] 47200000 47200005 
[phone] 47200006 
[phone] 47200007 
[phone] 47200008 47200000 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 23000000 23000001 
[phone] 23000001 23000002 
[phone] 23000001 23000003 
[phone] 23000004 
[phone] 23000000 23000005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 43300001 
[phone] 43300001 
+
+--------------------------------------------
[phone]
[phone] 16900001 
[phone] 16900002 
[phone] 16900001 16900003 
[phone] 16900004 
[phone] 16900003 16900005 
[phone] 16900006 
[phone] 16900004 16900007 
[phone] 16900003 
+
+--------------------------------------------
[phone]
[phone] 27400000 27400001 
[phone] 27400002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 17800000 
+
+--------------------------------------------
+8200000
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 26100001 
[phone] 26100002 
[phone] 26100000 26100003 
[phone] 26100004 
[phone] 26100005 
[phone] 26100006 
[phone] 26100007 
[phone] 26100008 
[phone] 26100009 
[phone] 26100010 
[phone] 26100005 
+
+--------------------------------------------
[phone]
[phone] 30700000 30700001 
[phone] 30700000 30700002 
[phone] 30700003 
[phone] 30700004 
[phone] 30700000 30700005 
[phone] 30700006 
[phone] 30700003 
+
+--------------------------------------------
+400000
[phone] 
[phone] 400002 
[phone] 
[phone] 
+400004 0 
+
+--------------------------------------------
[phone]
[phone] 35300001 
[phone] 35300002 
[phone] 35300000 
+
+--------------------------------------------
[phone]
[phone] 38700001 
[phone] 38700001 38700002 
[phone] 38700003 38700004 
[phone] 38700004 
[phone] 38700005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 39900000 39900001 
[phone] 39900002 
[phone] 39900003 
[phone] 39900004 39900007 
[phone] 39900005 
[phone] 39900006 
[phone] 39900007 
[phone] 39900008 39900006 
[phone] 39900008 
+
+--------------------------------------------
+9600000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44500001 
[phone] 44500002 
[phone] 44500003 
[phone] 44500003 44500004 
[phone] 44500005 
[phone] 44500006 
[phone] 44500007 
[phone] 44500008 44500011 
[phone] 44500009 
[phone] 44500010 
[phone] 44500011 
[phone] 44500012 
[phone] 44500002 
+
+--------------------------------------------
[phone]
[phone] 14200000 14200001 
[phone] 14200002 
[phone] 14200001 14200003 
[phone] 14200004 
[phone] 14200005 
[phone] 14200005 14200006 
[phone] 14200007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 49100001 
[phone] 49100002 
[phone] 49100000 49100003 
[phone] 49100004 
[phone] 49100001 49100005 
[phone] 49100003 
+
+--------------------------------------------
[phone]
[phone] 18800000 
+
+--------------------------------------------
[phone]
[phone] 23400001 
[phone] 23400002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 28000001 28000002 
[phone] 28000000 28000002 
[phone] 28000000 
+
+--------------------------------------------
[phone]
[phone] 22400000 22400001 
[phone] 22400000 
+
+--------------------------------------------
[phone]
[phone] 27200000 27200001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 32600000 32600001 
[phone] 32600002 32600003 
[phone] 32600003 
[phone] 32600003 32600004 
[phone] 32600005 
[phone] 32600002 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+4200000
[phone] 4200001 
[phone] 
+
+--------------------------------------------
+8800000
[phone] 
[phone] 8800005 
[phone] 8800003 
[phone] 
[phone] 8800005 
[phone] 
+
+--------------------------------------------
+9000000
[phone] 
+
+--------------------------------------------
+1500000
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 13400001 
[phone] 13400001 
+
+--------------------------------------------
[phone]
[phone] 43900001 
[phone] 43900001 43900002 
[phone] 43900003 
[phone] 43900004 
[phone] 43900005 
[phone] 43900006 43900007 
[phone] 43900007 
[phone] 43900008 
[phone] 43900009 43900007 
[phone] 43900010 
[phone] 43900011 
[phone] 43900012 
[phone] 43900013 43900007 
[phone] 43900009 43900014 
[phone] 43900012 43900015 
[phone] 43900016 
[phone] 43900017 
[phone] 43900018 43900013 
[phone] 43900019 43900007 
[phone] 43900020 
[phone] 
+
+--------------------------------------------
+6100000
[phone] 6100001 
[phone] 
[phone] 6100003 
[phone] 6100004 
[phone] 6100005 
[phone] 6100006 
[phone] 6100007 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 41000001 41000011 
[phone] 41000002 
[phone] 41000003 
[phone] 41000004 
[phone] 41000004 41000005 
[phone] 41000006 41000007 
[phone] 41000007 
[phone] 41000008 
[phone] 41000009 
[phone] 41000010 
[phone] 41000008 41000011 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 15300000 15300001 
[phone] 15300002 
[phone] 15300003 
[phone] 15300004 15300006 
[phone] 15300005 
[phone] 15300005 15300006 
[phone] 15300002 15300007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 19900000 19900001 
[phone] 19900000 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 27600000 
+
+--------------------------------------------
[phone]
[phone] 17400001 
[phone] 17400001 
+
+--------------------------------------------
[phone]
[phone] 29100000 
+
+--------------------------------------------
[phone]
[phone] 33700001 
[phone] 
+
+--------------------------------------------
+3400000
[phone] 
[phone] 
[phone] 
[phone] 3400004 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+8000000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42900001 
[phone] 42900002 
[phone] 42900003 
[phone] 42900004 
[phone] 42900002 42900005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 47500001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 11300001 11300004 
[phone] 11300002 
[phone] 11300003 11300004 
[phone] 11300004 
[phone] 11300005 
[phone] 11300006 
[phone] 11300003 11300007 
[phone] 11300008 11300000 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 17200001 
[phone] 17200000 
+
+--------------------------------------------
[phone]
[phone] 21800000 21800001 
[phone] 1300000 
+
+--------------------------------------------
[phone]
[phone] 26400001 
[phone] 26400002 
[phone] 26400003 
[phone] 26400000 26400004 
[phone] 26400005 
[phone] 26400006 
[phone] 26400002 
+
+--------------------------------------------
+700000
[phone] 700004 
[phone] 
[phone] 
[phone] 700004 
[phone] 
[phone] 700006 
[phone] 
+700007 0 
+
+--------------------------------------------
[phone]
[phone] 35600001 
[phone] 35600002 
[phone] 35600003 
[phone] 35600002 
+
+--------------------------------------------
+5300000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 27000001 27000005 
[phone] 27000002 
[phone] 27000003 
[phone] 27000002 27000004 
[phone] 27000002 27000005 
[phone] 27000001 
+
+--------------------------------------------
[phone]
[phone] 10900000 
+
+--------------------------------------------
[phone]
[phone] 44800000 
+
+--------------------------------------------
[phone]
[phone] 14500001 
[phone] 14500002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 19100001 
[phone] 19100002 
[phone] 19100003 
[phone] 19100003 
+
+--------------------------------------------
[phone]
[phone] 23700001 
[phone] 23700002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 28300001 
[phone] 28300002 
[phone] 28300001 28300003 
[phone] 28300004 
[phone] 28300005 
[phone] 28300005 28300006 
[phone] 28300007 
[phone] 28300008 
[phone] 28300000 28300009 
[phone] 28300010 
[phone] 28300011 
[phone] 28300012 
[phone] 28300013 28300006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 29900001 
[phone] 29900002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 32900001 32900002 
[phone] 32900000 32900002 
[phone] 
+
+--------------------------------------------
+2600000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37500001 
[phone] 37500002 
[phone] 37500000 37500003 
[phone] 37500001 37500004 
[phone] 37500005 
[phone] 37500006 
[phone] 37500007 
[phone] 37500008 37500006 
[phone] 37500009 
[phone] 
+
+--------------------------------------------
+7200000
[phone] 
[phone] 
[phone] 7200003 
[phone] 
[phone] 7200005 
[phone] 
[phone] 7200007 
[phone] 7200006 
[phone] 
[phone] 7200006 
[phone] 7200004 
[phone] 7200012 
[phone] 7200013 
[phone] 7200014 
[phone] 
[phone] 
[phone] 
[phone] 7200018 
[phone] 7200006 
[phone] 7200020 
[phone] 
[phone] 7200022 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42100001 42100004 
[phone] 42100002 
[phone] 42100003 
[phone] 42100004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 11800000 11800001 
[phone] 11800002 
[phone] 11800003 
[phone] 11800004 11800006 
[phone] 11800005 
[phone] 11800006 
[phone] 11800007 
[phone] 11800008 11800002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 46700001 
[phone] 46700000 46700002 
[phone] 46700003 
[phone] 46700003 46700004 
[phone] 46700005 
[phone] 46700003 
+
+--------------------------------------------
[phone]
[phone] 16400000 
+
+--------------------------------------------
[phone]
[phone] 13600008 13600001 
[phone] 13600001 13600002 
[phone] 13600002 13600003 
[phone] 13600004 
[phone] 13600004 13600005 
[phone] 13600004 13600006 
[phone] 13600007 
[phone] 13600008 
[phone] 13600009 13600002 
[phone] 13600010 13600004 
[phone] 13600011 
[phone] 13600003 
+
+--------------------------------------------
[phone]
[phone] 36400001 36400003 
[phone] 36400002 
[phone] 36400002 36400003 
[phone] 36400004 
[phone] 36400005 
[phone] 36400006 
[phone] 36400007 
[phone] 36400008 
[phone] 36400001 
+
+--------------------------------------------
[phone]
[phone] 25600001 25600002 
[phone] 25600002 
[phone] 25600001 25600003 
[phone] 25600004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 30200001 
[phone] 30200002 
[phone] 30200002 30200003 
[phone] 30200004 
[phone] 30200005 
[phone] 30200003 30200006 
[phone] 30200007 
[phone] 30200008 
[phone] 30200009 30200005 
[phone] 30200001 30200010 
[phone] 30200010 30200011 
[phone] 30200005 
+
+--------------------------------------------
[phone]
[phone] 34800001 
[phone] 34800002 
[phone] 34800000 
+
+--------------------------------------------
+4500000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44000001 
[phone] 44000001 44000002 
[phone] 44000002 
+
+--------------------------------------------
[phone]
[phone] 48500000 48500001 
[phone] 48500002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 13700001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 48600001 
[phone] 48600002 
[phone] 48600003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 18300001 
[phone] 18300002 
[phone] 18300003 
[phone] 18300003 
+
+--------------------------------------------
[phone]
[phone] 22900000 22900001 
[phone] 22900001 22900002 
[phone] 22900002 
+
+--------------------------------------------
[phone]
[phone] 27500000 27500001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 32100001 
[phone] 32100002 
[phone] 32100002 32100003 
[phone] 32100001 32100004 
[phone] 32100005 
[phone] 32100003 32100006 
[phone] 32100007 
[phone] 32100008 32100002 
[phone] 32100008 32100009 
[phone] 32100010 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 32200000 32200001 
[phone] 32200002 
[phone] 32200003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 10700000 10700001 
[phone] 10700001 10700002 
[phone] 10700003 10700004 
[phone] 10700004 
[phone] 10700005 
[phone] 10700006 
[phone] 10700001 10700007 
[phone] 10700008 10700003 
[phone] 10700009 10700005 
[phone] 10700010 
[phone] 10700011 
[phone] 
+
+--------------------------------------------
+6400000
[phone] 
[phone] 
[phone] 6400006 
[phone] 6400007 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 41300001 
[phone] 41300002 
[phone] 41300002 
+
+--------------------------------------------
[phone]
[phone] 11000000 11000001 
[phone] 11000000 11000002 
[phone] 11000002 11000003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45900001 
[phone] 45900002 
[phone] 45900001 
+
+--------------------------------------------
[phone]
[phone] 15600001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 20200001 31600000 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 24800001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 15900000 15900001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 29400065 29400001 
[phone] 29400066 29400019 
[phone] 29400067 29400051 
[phone] 29400068 29400063 
[phone] 29400069 10000000 
[phone] 29400070 1500000 
[phone] 29400071 46000000 
[phone] 29400072 29400036 
[phone] 29400073 43700000 
[phone] 29400074 35000000 
[phone] 29400075 29400011 
[phone] 29400035 29400076 
[phone] 29400077 27300000 
[phone] 29400078 41700000 
[phone] 29400079 
[phone] 29400080 36800000 
[phone] 29400081 13500000 
[phone] 29400082 29400141 
[phone] 29400083 23000000 
[phone] 29400065 29400084 
[phone] 29400085 29400087 
[phone] 29400086 30500000 
[phone] 29400087 36200000 
[phone] 29400088 29400126 
[phone] 29400089 29400041 
[phone] 29400090 29400047 
[phone] 29400091 5400000 
[phone] 29400107 29400092 
[phone] 29400093 29400095 
[phone] 29400025 29400094 
[phone] 29400000 29400095 
[phone] 29400096 29400070 
[phone] 29400097 4900000 
[phone] 29400098 29400092 
[phone] 29400099 18400000 
[phone] 29400073 29400100 
[phone] 29400101 29400069 
[phone] 29400032 29400102 
[phone] 29400103 21600000 
[phone] 29400104 12600000 
[phone] 29400104 29400105 
[phone] 29400106 10700000 
[phone] 29400107 29400046 
[phone] 29400001 29400108 
[phone] 29400109 37100000 
[phone] 29400057 29400110 
[phone] 29400111 34200000 
[phone] 29400112 46700000 
[phone] 29400113 10500000 
[phone] 29400114 15100000 
[phone] 29400115 30200000 
[phone] 29400116 29400030 
[phone] 29400117 31500000 
[phone] 29400016 29400118 
[phone] 29400061 29400119 
[phone] 29400120 37500000 
[phone] 29400121 29400098 
[phone] 29400122 40800000 
[phone] 29400123 24000000 
[phone] 29400112 29400124 
[phone] 29400125 29400086 
[phone] 29400126 46900000 
[phone] 29400127 9100000 
[phone] 29400128 28400000 
[phone] 29400129 4600000 
[phone] 29400130 29400125 
[phone] 29400131 600000 
[phone] 29400132 18800000 
[phone] 29400133 17000000 
[phone] 29400134 29400047 
[phone] 29400135 13200000 
[phone] 29400136 29100000 
[phone] 29400137 6200000 
[phone] 29400138 29400010 
[phone] 29400139 10400000 
[phone] 29400056 29400140 
[phone] 29400027 29400141 
[phone] 29400142 22300000 
[phone] 29400032 29400143 
[phone] 29400144 49800000 
[phone] 29400145 48400000 
[phone] 29400146 49300000 
[phone] 29400139 26600000 
[phone] 29400001 35900000 
[phone] 29400002 48500000 
[phone] 29400003 29400035 
[phone] 29400003 29400004 
[phone] 29400005 36300000 
[phone] 29400123 29400006 
[phone] 29400007 32400000 
[phone] 29400008 29400042 
[phone] 29400009 29400006 
[phone] 29400010 45900000 
[phone] 29400010 29400011 
[phone] 29400012 2100000 
[phone] 29400013 17100000 
[phone] 29400130 29400014 
[phone] 29400113 29400015 
[phone] 29400016 7800000 
[phone] 29400017 22700000 
[phone] 29400018 34100000 
[phone] 29400019 43600000 
[phone] 29400020 29400014 
[phone] 29400021 44400000 
[phone] 29400022 29400087 
[phone] 29400132 29400023 
[phone] 29400024 37300000 
[phone] 29400025 28300000 
[phone] 29400026 29400021 
[phone] 29400027 900000 
[phone] 29400028 29400006 
[phone] 29400029 29400071 
[phone] 29400030 40900000 
[phone] 29400031 17800000 
[phone] 29400032 2900000 
[phone] 29400033 21500000 
[phone] 29400034 29400011 
[phone] 29400035 29400007 
[phone] 29400034 29400036 
[phone] 29400081 29400037 
[phone] 29400038 45600000 
[phone] 29400010 29400039 
[phone] 29400040 29400020 
[phone] 29400041 29400028 
[phone] 29400042 29400004 
[phone] 29400064 29400043 
[phone] 29400084 29400044 
[phone] 29400045 29400085 
[phone] 29400026 29400046 
[phone] 29400047 2200000 
[phone] 29400048 29400006 
[phone] 29400049 35300000 
[phone] 29400050 47200000 
[phone] 29400064 29400051 
[phone] 29400052 9000000 
[phone] 29400053 29400005 
[phone] 29400054 5900000 
[phone] 29400031 29400055 
[phone] 29400056 33800000 
[phone] 29400057 29400132 
[phone] 29400129 29400058 
[phone] 29400080 29400059 
[phone] 29400060 34300000 
[phone] 29400010 29400061 
[phone] 29400099 29400062 
[phone] 29400063 30900000 
[phone] 29400064 14900000 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+3700000
[phone] 
[phone] 3700007 
[phone] 3700003 
[phone] 
[phone] 
[phone] 
[phone] 3700007 
[phone] 3700006 
[phone] 3700005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 38600000 38600001 
[phone] 38600002 
[phone] 38600003 
[phone] 
+
+--------------------------------------------
+8300000
[phone] 8300004 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 43200001 43200002 
[phone] 43200000 43200002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 12900001 47100000 
[phone] 12900002 15000000 
[phone] 12900003 40700000 
[phone] 12900004 14400000 
[phone] 12900005 20500000 
[phone] 12900006 48100000 
[phone] 12900007 18500000 
[phone] 12900008 44700000 
[phone] 12900009 12900002 
[phone] 12900010 23900000 
[phone] 12900011 3900000 
[phone] 12900012 39100000 
[phone] 12900013 30000000 
[phone] 12900014 3300000 
[phone] 12900012 12900015 
[phone] 12900016 12900003 
[phone] 12900017 46200000 
[phone] 12900018 5200000 
[phone] 12900200 12900019 
[phone] 12900020 12900005 
[phone] 12900021 18000000 
[phone] 12900014 12900022 
[phone] 12900019 12900023 
[phone] 12900024 12900228 
[phone] 12900025 15700000 
[phone] 12900026 12900003 
[phone] 12900027 21300000 
[phone] 12900028 20300000 
[phone] 12900322 12900029 
[phone] 12900018 12900030 
[phone] 12900031 43400000 
[phone] 12900032 12900190 
[phone] 12900033 15900000 
[phone] 12900034 12900018 
[phone] 12900035 12900246 
[phone] 12900036 24800000 
[phone] 12900256 12900037 
[phone] 12900038 18200000 
[phone] 12900131 12900039 
[phone] 12900040 12900039 
[phone] 12900041 26100000 
[phone] 12900042 12900027 
[phone] 12900043 12900275 
[phone] 12900034 12900044 
[phone] 12900045 31400000 
[phone] 12900046 44500000 
[phone] 12900145 12900047 
[phone] 12900048 49500000 
[phone] 12900048 12900049 
[phone] 12900050 18900000 
[phone] 12900051 12900045 
[phone] 12900052 23100000 
[phone] 12900053 49100000 
[phone] 12900035 12900054 
[phone] 12900315 12900055 
[phone] 12900056 100000 
[phone] 12900057 12900053 
[phone] 12900058 6400000 
[phone] 12900059 12900027 
[phone] 12900000 12900060 
[phone] 12900177 12900061 
[phone] 12900062 12900135 
[phone] 12900063 9700000 
[phone] 12900064 12900041 
[phone] 12900065 45300000 
[phone] 12900066 12900005 
[phone] 12900067 11700000 
[phone] 12900000 12900068 
[phone] 12900069 21200000 
[phone] 12900070 16100000 
[phone] 12900007 12900071 
[phone] 12900072 20200000 
[phone] 12900073 21100000 
[phone] 12900074 12900019 
[phone] 12900075 12900046 
[phone] 12900036 12900076 
[phone] 12900077 12900061 
[phone] 12900078 26400000 
[phone] 12900254 12900079 
[phone] 12900080 12900016 
[phone] 12900081 12900075 
[phone] 12900082 12900002 
[phone] 12900082 12900083 
[phone] 12900018 12900084 
[phone] 12900085 33600000 
[phone] 12900086 16700000 
[phone] 12900087 26200000 
[phone] 12900088 12900300 
[phone] 12900089 3200000 
[phone] 12900090 22200000 
[phone] 12900091 7400000 
[phone] 12900092 400000 
[phone] 12900093 2400000 
[phone] 12900094 24600000 
[phone] 12900095 15600000 
[phone] 12900096 39300000 
[phone] 12900097 12900068 
[phone] 12900098 34000000 
[phone] 12900217 12900099 
[phone] 12900100 14300000 
[phone] 12900101 31900000 
[phone] 12900102 1200000 
[phone] 12900103 11300000 
[phone] 12900104 8400000 
[phone] 12900105 12900257 
[phone] 12900106 19700000 
[phone] 12900107 12900075 
[phone] 12900267 12900108 
[phone] 12900109 1800000 
[phone] 12900004 12900110 
[phone] 12900245 12900111 
[phone] 12900112 30100000 
[phone] 12900000 12900113 
[phone] 12900114 5700000 
[phone] 12900115 13400000 
[phone] 12900116 12900326 
[phone] 12900088 12900117 
[phone] 12900118 15800000 
[phone] 12900233 12900119 
[phone] 12900120 33100000 
[phone] 12900121 32100000 
[phone] 12900122 12900270 
[phone] 12900123 34600000 
[phone] 12900124 31300000 
[phone] 12900125 12900045 
[phone] 12900118 12900126 
[phone] 12900076 12900127 
[phone] 12900128 33500000 
[phone] 12900129 12900169 
[phone] 12900130 14000000 
[phone] 12900131 24400000 
[phone] 12900060 12900132 
[phone] 12900133 19100000 
[phone] 12900134 35600000 
[phone] 12900135 700000 
[phone] 12900136 
[phone] 12900137 19400000 
[phone] 12900138 42400000 
[phone] 12900139 43800000 
[phone] 12900153 12900140 
[phone] 12900141 12900245 
[phone] 12900142 12900191 
[phone] 12900143 35100000 
[phone] 12900144 48300000 
[phone] 12900336 12900145 
[phone] 12900146 27100000 
[phone] 12900147 12900038 
[phone] 12900176 12900148 
[phone] 12900149 27500000 
[phone] 12900121 12900150 
[phone] 12900089 12900151 
[phone] 12900152 12900086 
[phone] 12900153 12900189 
[phone] 12900154 36000000 
[phone] 12900155 36900000 
[phone] 12900156 12900029 
[phone] 12900157 41400000 
[phone] 12900158 41600000 
[phone] 12900108 12900159 
[phone] 12900160 12900113 
[phone] 12900161 17700000 
[phone] 12900162 16900000 
[phone] 12900163 12900067 
[phone] 12900128 12900164 
[phone] 12900232 12900165 
[phone] 12900029 12900166 
[phone] 12900167 25900000 
[phone] 12900168 12900048 
[phone] 12900169 2000000 
[phone] 12900016 12900170 
[phone] 12900171 21900000 
[phone] 12900153 12900172 
[phone] 12900173 33700000 
[phone] 12900174 42300000 
[phone] 12900178 12900175 
[phone] 12900176 12900191 
[phone] 12900177 12900130 
[phone] 12900178 12900132 
[phone] 12900106 12900179 
[phone] 12900180 29200000 
[phone] 12900181 35400000 
[phone] 12900041 12900182 
[phone] 12900227 12900183 
[phone] 12900184 12900109 
[phone] 12900185 12900300 
[phone] 12900186 9200000 
[phone] 12900187 12900023 
[phone] 12900188 26700000 
[phone] 12900189 30600000 
[phone] 12900064 12900190 
[phone] 12900177 12900191 
[phone] 12900192 35800000 
[phone] 12900080 12900193 
[phone] 12900194 17900000 
[phone] 12900105 12900195 
[phone] 12900196 12900062 
[phone] 12900197 12900142 
[phone] 12900198 41100000 
[phone] 12900199 13100000 
[phone] 12900200 12900185 
[phone] 12900104 12900201 
[phone] 12900202 27600000 
[phone] 12900203 38900000 
[phone] 12900204 36700000 
[phone] 12900180 12900205 
[phone] 12900206 12900311 
[phone] 12900028 12900207 
[phone] 12900208 12900010 
[phone] 12900209 12900186 
[phone] 12900210 31800000 
[phone] 12900211 26300000 
[phone] 12900212 29700000 
[phone] 12900213 11600000 
[phone] 12900214 300000 
[phone] 12900215 4400000 
[phone] 12900216 34800000 
[phone] 12900217 22000000 
[phone] 12900218 37200000 
[phone] 12900219 18300000 
[phone] 12900220 12900069 
[phone] 12900221 12900222 
[phone] 12900222 16600000 
[phone] 12900223 3700000 
[phone] 12900224 47600000 
[phone] 12900225 17200000 
[phone] 12900226 12900038 
[phone] 12900227 12900207 
[phone] 12900228 26500000 
[phone] 12900229 12500000 
[phone] 12900162 12900230 
[phone] 12900231 23400000 
[phone] 12900232 25800000 
[phone] 12900233 12900265 
[phone] 12900032 12900234 
[phone] 12900235 48900000 
[phone] 12900236 21700000 
[phone] 12900155 12900237 
[phone] 12900012 12900238 
[phone] 12900239 6800000 
[phone] 12900240 7300000 
[phone] 12900241 12900170 
[phone] 12900242 12900246 
[phone] 12900243 25600000 
[phone] 12900099 12900244 
[phone] 12900050 12900245 
[phone] 12900068 12900246 
[phone] 12900247 3500000 
[phone] 12900248 45700000 
[phone] 12900249 6700000 
[phone] 12900250 12900181 
[phone] 12900251 20800000 
[phone] 12900252 12900270 
[phone] 12900120 12900253 
[phone] 12900254 19200000 
[phone] 12900255 26000000 
[phone] 12900256 12900118 
[phone] 12900257 12900004 
[phone] 12900258 12900135 
[phone] 12900154 12900259 
[phone] 12900260 43000000 
[phone] 12900096 12900261 
[phone] 12900010 12900262 
[phone] 12900263 46400000 
[phone] 12900264 12900223 
[phone] 12900265 12900002 
[phone] 12900266 32000000 
[phone] 12900267 2800000 
[phone] 12900114 12900268 
[phone] 12900269 7500000 
[phone] 12900156 12900270 
[phone] 12900005 12900271 
[phone] 12900272 12900154 
[phone] 12900273 12900085 
[phone] 12900274 8900000 
[phone] 12900275 42500000 
[phone] 12900050 12900276 
[phone] 12900277 43500000 
[phone] 12900098 12900278 
[phone] 12900217 12900279 
[phone] 12900280 31700000 
[phone] 12900281 12900002 
[phone] 12900282 48700000 
[phone] 12900146 12900283 
[phone] 12900284 11000000 
[phone] 12900128 12900285 
[phone] 12900286 12900079 
[phone] 12900152 12900287 
[phone] 12900288 12900183 
[phone] 12900289 12900012 
[phone] 12900290 12900310 
[phone] 12900291 27200000 
[phone] 12900292 31600000 
[phone] 12900293 45400000 
[phone] 12900118 12900294 
[phone] 12900307 12900295 
[phone] 12900296 12900180 
[phone] 12900297 25100000 
[phone] 12900298 15300000 
[phone] 12900299 16200000 
[phone] 12900300 43100000 
[phone] 12900301 12900262 
[phone] 12900302 12900279 
[phone] 12900239 12900303 
[phone] 12900304 38800000 
[phone] 12900305 12900121 
[phone] 12900306 24700000 
[phone] 12900307 46800000 
[phone] 12900009 12900308 
[phone] 12900309 5800000 
[phone] 12900310 12900199 
[phone] 12900311 28900000 
[phone] 12900312 13300000 
[phone] 12900313 3400000 
[phone] 12900314 1300000 
[phone] 12900315 43200000 
[phone] 12900051 12900316 
[phone] 12900317 47300000 
[phone] 12900224 12900318 
[phone] 12900014 12900319 
[phone] 12900320 12900247 
[phone] 12900321 12900103 
[phone] 12900322 12900111 
[phone] 12900323 15500000 
[phone] 12900324 49900000 
[phone] 12900156 12900325 
[phone] 12900065 12900326 
[phone] 12900327 5300000 
[phone] 12900328 5000000 
[phone] 12900329 12900156 
[phone] 12900330 12900301 
[phone] 12900331 27900000 
[phone] 12900332 10600000 
[phone] 12900333 12900325 
[phone] 12900334 3600000 
[phone] 12900080 12900335 
[phone] 12900336 12900182 
[phone] 12900337 34400000 
[phone] 45000000 
+
+--------------------------------------------
[phone]
[phone] 47800001 
[phone] 47800002 
[phone] 47800003 
[phone] 47800003 
+
+--------------------------------------------
[phone]
[phone] 31600000 31600001 
[phone] 31600002 
[phone] 31600003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45800001 45800002 
[phone] 45800002 
[phone] 45800003 
[phone] 45800002 45800004 
[phone] 45800002 
+
+--------------------------------------------
[phone]
[phone] 22100001 
[phone] 22100002 
[phone] 22100003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 26700000 
+
+--------------------------------------------
[phone]
[phone] 31300001 
[phone] 31300002 
[phone] 31300003 31300005 
[phone] 31300000 31300004 
[phone] 31300005 
[phone] 31300006 
[phone] 31300007 
[phone] 31300008 31300000 
[phone] 31300009 
[phone] 31300010 
[phone] 31300002 31300011 
[phone] 31300005 
+
+--------------------------------------------
+1000000
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 1000005 
[phone] 
[phone] 1000007 
[phone] 
[phone] 1000005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 35900000 
+
+--------------------------------------------
+5600000
[phone] 
[phone] 5600002 
[phone] 
[phone] 5600004 
[phone] 
[phone] 5600006 
[phone] 
[phone] 
[phone] 5600004 
[phone] 
[phone] 5600011 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 40500001 
[phone] 40500002 
[phone] 40500000 
+
+--------------------------------------------
[phone]
[phone] 8100000 
+
+--------------------------------------------
[phone]
[phone] 10200001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45100001 
[phone] 45100002 
[phone] 45100003 
[phone] 45100003 45100004 
[phone] 45100005 
[phone] 45100006 
[phone] 45100001 
+
+--------------------------------------------
[phone]
[phone] 14800001 
[phone] 14800002 
[phone] 14800003 
[phone] 14800000 14800004 
[phone] 14800000 14800005 
[phone] 14800000 
+
+--------------------------------------------
[phone]
[phone] 49700001 
[phone] 49700001 
+
+--------------------------------------------
[phone]
[phone] 19400001 
[phone] 19400002 
[phone] 19400003 
[phone] 19400004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 24000001 
[phone] 24000002 
[phone] 24000000 24000003 
[phone] 24000004 
[phone] 24000005 
[phone] 24000006 
[phone] 24000001 24000007 
[phone] 24000008 24000010 
[phone] 24000009 
[phone] 24000010 
[phone] 24000008 
+
+--------------------------------------------
[phone]
[phone] 28600001 28600002 
[phone] 28600002 28600012 
[phone] 28600003 
[phone] 28600004 28600007 
[phone] 28600005 
[phone] 28600006 
[phone] 28600007 
[phone] 28600008 
[phone] 28600009 
[phone] 28600010 
[phone] 28600011 
[phone] 28600003 28600012 
[phone] 28600000 28600013 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 31000001 
[phone] 31000001 31000002 
[phone] 31000001 31000003 
[phone] 31000004 
[phone] 31000003 31000005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 20100000 20100001 
[phone] 20100002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 33200000 
+
+--------------------------------------------
+2900000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37800000 37800001 
[phone] 37800000 37800002 
[phone] 37800003 
[phone] 37800002 
+
+--------------------------------------------
+7500000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42400000 42400001 
[phone] 42400000 42400002 
[phone] 42400000 42400003 
[phone] 42400004 
[phone] 42400005 
[phone] 42400006 
[phone] 42400007 
[phone] 42400008 42400006 
[phone] 42400009 
[phone] 42400010 42400006 
[phone] 42400011 
[phone] 42400012 
[phone] 42400013 
[phone] 42400014 
[phone] 42400004 
+
+--------------------------------------------
[phone]
[phone] 12100001 
[phone] 12100001 
+
+--------------------------------------------
[phone]
[phone] 47000001 
[phone] 47000002 
[phone] 47000001 47000003 
[phone] 47000001 47000004 
[phone] 47000005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 16700000 
+
+--------------------------------------------
[phone]
[phone] 21300000 
+
+--------------------------------------------
[phone]
[phone] 33900001 33900003 
[phone] 33900002 
[phone] 33900003 33900007 
[phone] 33900004 
[phone] 33900005 
[phone] 33900006 
[phone] 33900005 33900007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 30500000 
+
+--------------------------------------------
+200000
+200000 0 
+
+--------------------------------------------
[phone]
[phone] 35100001 
[phone] 35100001 35100002 
[phone] 35100003 
[phone] 35100000 35100004 
[phone] 
+
+--------------------------------------------
+4800000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 39700001 39700002 
[phone] 39700000 39700002 
[phone] 39700000 39700003 
[phone] 39700003 
+
+--------------------------------------------
+9400000
[phone] 
[phone] 
[phone] 9400003 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44300001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36800001 
[phone] 36800001 
+
+--------------------------------------------
[phone]
[phone] 45600001 
[phone] 45600000 45600002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 48900001 
[phone] 48900001 
+
+--------------------------------------------
+2100000
[phone] 
[phone] 
[phone] 2100003 
[phone] 2100004 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 33300001 
[phone] 33300002 
[phone] 33300001 33300003 
[phone] 33300000 33300004 
[phone] 33300005 
[phone] 33300006 
[phone] 
+
+--------------------------------------------
+6700000
[phone] 6700001 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 46200001 46200006 
[phone] 46200002 
[phone] 46200003 46200005 
[phone] 46200004 46200007 
[phone] 46200005 
[phone] 46200005 46200006 
[phone] 46200007 
[phone] 46200008 
[phone] 46200009 46200006 
[phone] 46200001 
+
+--------------------------------------------
[phone]
[phone] 20500001 
[phone] 20500000 
+
+--------------------------------------------
[phone]
[phone] 25100001 
[phone] 25100002 25100003 
[phone] 25100000 25100003 
[phone] 25100004 
[phone] 25100005 
[phone] 25100006 
[phone] 25100006 25100007 
[phone] 25100008 25100007 
[phone] 25100009 
[phone] 25100010 
[phone] 25100006 
+
+--------------------------------------------
[phone]
[phone] 49000001 49000003 
[phone] 49000002 49000004 
[phone] 49000003 
[phone] 49000003 49000004 
[phone] 49000000 
+
+--------------------------------------------
[phone]
[phone] 29500001 29500012 
[phone] 29500002 
[phone] 29500009 29500003 
[phone] 29500004 
[phone] 29500005 
[phone] 29500006 
[phone] 29500007 
[phone] 29500008 
[phone] 29500009 29500007 
[phone] 29500010 
[phone] 29500011 
[phone] 29500002 29500012 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36700001 
[phone] 36700000 36700002 
[phone] 36700003 
[phone] 36700001 36700004 
[phone] 36700005 
[phone] 36700005 36700006 
[phone] 36700004 
+
+--------------------------------------------
[phone]
[phone] 17500000 
+
+--------------------------------------------
[phone]
[phone] 34300000 
+
+--------------------------------------------
+4000000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 38900000 38900001 
[phone] 38900002 
[phone] 38900001 
+
+--------------------------------------------
[phone]
[phone] 43500001 
[phone] 43500002 
[phone] 43500000 43500003 
[phone] 43500001 43500004 
[phone] 43500002 43500005 
[phone] 43500003 
+
+--------------------------------------------
[phone]
[phone] 13200001 
[phone] 13200002 
[phone] 13200003 
[phone] 13200000 13200004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 48100001 
[phone] 48100001 
+
+--------------------------------------------
[phone]
[phone] 39100001 
[phone] 39100000 39100002 
[phone] 39100001 39100003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 43400001 43400005 
[phone] 43400002 
[phone] 43400003 
[phone] 43400004 43400006 
[phone] 43400002 43400005 
[phone] 43400003 43400006 
[phone] 43400003 
+
+--------------------------------------------
[phone]
[phone] 33800000 
+
+--------------------------------------------
[phone]
[phone] 24200008 24200001 
[phone] 24200002 
[phone] 24200002 24200003 
[phone] 24200008 24200004 
[phone] 24200001 24200005 
[phone] 24200004 24200006 
[phone] 24200008 24200007 
[phone] 24200008 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 14600001 
[phone] 14600000 14600002 
[phone] 14600002 14600003 
[phone] 14600004 
[phone] 14600005 
[phone] 14600001 14600006 
[phone] 14600007 
[phone] 14600008 14600005 
[phone] 14600009 
[phone] 
+
+--------------------------------------------
+1300000
[phone] 1300001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36200001 
[phone] 36200001 
+
+--------------------------------------------
[phone]
[phone] 40800001 40800002 
[phone] 40800002 
[phone] 40800001 40800003 
[phone] 40800003 40800004 
[phone] 40800005 
[phone] 40800002 
+
+--------------------------------------------
+3600000
[phone] 3600002 
[phone] 
[phone] 3600003 
[phone] 
+
+--------------------------------------------
+3800000
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 3800007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 45400001 
[phone] 45400000 45400002 
[phone] 45400003 
[phone] 45400004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 15100001 
[phone] 15100002 15100003 
[phone] 15100001 15100003 
[phone] 15100002 
+
+--------------------------------------------
[phone]
[phone] 19700001 
[phone] 19700002 
[phone] 19700003 
[phone] 19700004 19700007 
[phone] 19700005 
[phone] 19700006 
[phone] 19700002 19700007 
[phone] 19700008 
[phone] 19700009 
[phone] 19700010 
[phone] 19700011 
[phone] 19700012 
[phone] 19700011 
+
+--------------------------------------------
[phone]
[phone] 24300001 
[phone] 24300002 
[phone] 24300000 24300003 
[phone] 24300004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 28900000 28900001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 33500000 33500001 
[phone] 33500001 
+
+--------------------------------------------
+3200000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 38100001 
[phone] 
+
+--------------------------------------------
+7800000
[phone] 
[phone] 7800002 
[phone] 7800003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42700000 42700001 
[phone] 42700000 42700002 
[phone] 42700003 
[phone] 42700004 
[phone] 42700005 
[phone] 42700001 42700006 
[phone] 42700007 
[phone] 42700008 
[phone] 42700009 
[phone] 42700000 42700010 
[phone] 42700011 
[phone] 42700012 
[phone] 42700002 
+
+--------------------------------------------
[phone]
[phone] 12400000 12400001 
[phone] 12400000 26200000 
+
+--------------------------------------------
[phone]
[phone] 47300001 
[phone] 47300002 47300007 
[phone] 47300000 47300003 
[phone] 47300000 47300004 
[phone] 47300005 47300006 
[phone] 47300006 
[phone] 47300004 47300007 
[phone] 47300008 47300006 
[phone] 47300009 
[phone] 47300000 47300010 
[phone] 47300011 47300007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 17000001 
[phone] 17000001 
+
+--------------------------------------------
[phone]
[phone] 21600001 21600007 
[phone] 21600002 21600006 
[phone] 21600003 
[phone] 21600009 21600004 
[phone] 21600009 21600005 
[phone] 21600000 21600006 
[phone] 21600007 
[phone] 21600008 
[phone] 21600009 
[phone] 21600010 
[phone] 21600011 21600007 
[phone] 21600012 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 29300000 
+
+--------------------------------------------
[phone]
[phone] 26200000 26200001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+500000
[phone] 
[phone] 500002 
[phone] 
[phone] 
[phone] 
[phone] 500006 
[phone] 500007 
[phone] 
[phone] 500009 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+5100000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+9700000
[phone] 
[phone] 9700002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 44600001 
[phone] 44600001 44600002 
[phone] 44600003 
[phone] 44600000 44600004 
[phone] 44600005 
[phone] 44600004 
+
+--------------------------------------------
+5900000
[phone] 
[phone] 
[phone] 5900003 
[phone] 
[phone] 
[phone] 5900006 
[phone] 5900007 
[phone] 5900000 
[phone] 5900006 
[phone] 5900010 
[phone] 5900006 
[phone] 5900006 
[phone] 5900013 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 14300001 14300003 
[phone] 14300001 14300002 
[phone] 14300003 
[phone] 14300002 14300004 
[phone] 14300005 
[phone] 14300006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 49200001 
[phone] 49200009 49200002 
[phone] 49200003 
[phone] 49200004 
[phone] 49200005 
[phone] 49200006 
[phone] 49200000 49200007 
[phone] 49200008 
[phone] 49200009 
[phone] 49200010 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 18900001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 23500001 
[phone] 23500001 
+
+--------------------------------------------
[phone]
[phone] 28100000 28100001 
[phone] 28100001 
+
+--------------------------------------------
[phone]
[phone] 32700033 21000000 
[phone] 32700034 48000000 
[phone] 32700002 
[phone] 32700001 32700021 
[phone] 32700002 37700000 
[phone] 32700003 9400000 
[phone] 32700004 
[phone] 32700000 32700005 
[phone] 32700002 32700006 
[phone] 32700007 39800000 
[phone] 32700008 32700033 
[phone] 32700008 32700009 
[phone] 32700010 38000000 
[phone] 32700011 11100000 
[phone] 32700012 47700000 
[phone] 32700013 
[phone] 32700005 32700014 
[phone] 32700032 32700015 
[phone] 32700016 
[phone] 32700017 32700009 
[phone] 32700018 32700015 
[phone] 32700019 
[phone] 32700020 32700021 
[phone] 32700021 39400000 
[phone] 32700022 1600000 
[phone] 32700023 17600000 
[phone] 32700024 32700019 
[phone] 32700025 22500000 
[phone] 32700026 32700013 
[phone] 32700027 34500000 
[phone] 32700028 3800000 
[phone] 32700029 28700000 
[phone] 32700030 37600000 
[phone] 32700015 32700031 
[phone] 32700032 32700000 
+
+--------------------------------------------
+2400000
[phone] 2400001 
[phone] 2400002 
[phone] 16400000 
+
+--------------------------------------------
[phone]
[phone] 37300001 
[phone] 37300002 
[phone] 37300003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 34400001 
[phone] 34400002 
[phone] 34400000 34400003 
[phone] 34400004 
[phone] 34400001 34400005 
[phone] 34400000 34400006 
[phone] 34400000 
+
+--------------------------------------------
+6800000
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 6800002 
[phone] 
[phone] 
+
+--------------------------------------------
+7000000
[phone] 
[phone] 7000002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 41900000 41900001 
[phone] 41900000 
+
+--------------------------------------------
[phone]
[phone] 11600001 11600006 
[phone] 11600002 
[phone] 11600001 11600003 
[phone] 11600002 11600004 
[phone] 11600004 11600005 
[phone] 11600006 
[phone] 11600005 11600007 
[phone] 11600008 
[phone] 11600009 
[phone] 11600010 
[phone] 11600011 11600003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 46500001 
[phone] 46500002 
[phone] 46500003 
[phone] 46500003 
+
+--------------------------------------------
[phone]
[phone] 16200001 
[phone] 16200002 
[phone] 16200001 
+
+--------------------------------------------
[phone]
[phone] 20800000 20800001 
[phone] 20800002 
[phone] 20800018 20800003 
[phone] 20800004 
[phone] 20800005 
[phone] 20800006 
[phone] 20800007 
[phone] 20800008 20800006 
[phone] 20800016 20800009 
[phone] 20800010 
[phone] 20800010 20800011 
[phone] 20800012 
[phone] 20800013 
[phone] 20800006 20800014 
[phone] 20800000 20800015 
[phone] 20800016 
[phone] 20800017 
[phone] 20800018 
[phone] 20800019 20800005 
[phone] 20800020 
[phone] 20800005 
+
+--------------------------------------------
[phone]
[phone] 25400001 
[phone] 25400002 25400004 
[phone] 25400003 
[phone] 25400003 25400004 
[phone] 25400005 25400006 
[phone] 25400006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 43700001 
[phone] 43700002 43700006 
[phone] 43700003 
[phone] 43700004 
[phone] 43700005 
[phone] 43700006 
[phone] 43700000 
+
+--------------------------------------------
[phone]
[phone] 30000000 30000001 
[phone] 30000002 
[phone] 30000003 
[phone] 30000000 30000004 
[phone] 30000005 
[phone] 30000008 30000006 
[phone] 30000006 30000007 
[phone] 30000008 
[phone] 30000009 
[phone] 30000010 
[phone] 30000011 
[phone] 30000010 
+
+--------------------------------------------
[phone]
[phone] 34600001 34600014 
[phone] 34600002 
[phone] 34600003 
[phone] 34600004 
[phone] 34600005 34600007 
[phone] 34600001 34600006 
[phone] 34600005 34600007 
[phone] 34600008 34600011 
[phone] 34600009 34600013 
[phone] 34600010 34600007 
[phone] 34600010 34600011 
[phone] 34600012 
[phone] 34600004 34600013 
[phone] 34600014 
[phone] 34600015 
[phone] 
+
+--------------------------------------------
+4300000
[phone] 
[phone] 4300002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 39200001 
[phone] 39200002 
[phone] 39200003 
[phone] 39200004 
[phone] 39200005 
[phone] 39200006 
[phone] 39200007 
[phone] 39200008 
[phone] 39200003 
+
+--------------------------------------------
+8900000
[phone] 
[phone] 
[phone] 8900003 
[phone] 8900006 
[phone] 8900005 
[phone] 
[phone] 8900007 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 13500000 13500001 
[phone] 13500002 13500004 
[phone] 13500001 13500003 
[phone] 13500016 13500004 
[phone] 13500017 13500005 
[phone] 13500006 
[phone] 13500004 13500007 
[phone] 13500008 
[phone] 13500009 
[phone] 13500010 13500005 
[phone] 13500011 
[phone] 13500002 13500012 
[phone] 13500013 
[phone] 13500019 13500014 
[phone] 13500015 
[phone] 13500016 
[phone] 13500017 13500003 
[phone] 13500018 
[phone] 13500018 13500019 
[phone] 13500020 13500022 
[phone] 13500021 
[phone] 13500013 13500022 
[phone] 13500013 
+
+--------------------------------------------
[phone]
[phone] 48400001 
[phone] 48400002 48400004 
[phone] 48400003 
[phone] 48400002 48400004 
[phone] 48400001 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 46600001 46600006 
[phone] 46600002 
[phone] 46600003 
[phone] 46600004 
[phone] 46600005 
[phone] 46600006 
[phone] 46600007 
[phone] 46600008 46600006 
[phone] 46600002 
+
+--------------------------------------------
+9900000
[phone] 9900001 
[phone] 
[phone] 9900003 
[phone] 
[phone] 9900005 
[phone] 9900006 
[phone] 
[phone] 
[phone] 
[phone] 9900004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 22700000 
+
+--------------------------------------------
[phone]
[phone] 27300001 
[phone] 27300002 27300004 
[phone] 27300003 27300007 
[phone] 27300003 27300004 
[phone] 27300005 
[phone] 27300006 
[phone] 27300000 27300007 
[phone] 27300008 27300004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 31900000 31900001 
[phone] 
+
+--------------------------------------------
+1600000
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 36500001 
[phone] 36500002 36500006 
[phone] 36500003 
[phone] 36500000 36500004 
[phone] 36500008 36500005 
[phone] 36500006 
[phone] 36500012 36500007 
[phone] 36500008 
[phone] 36500009 
[phone] 36500010 
[phone] 36500011 
[phone] 36500004 36500012 
[phone] 36500013 
[phone] 36500014 36500015 
[phone] 36500015 
[phone] 36500002 
+
+--------------------------------------------
+6200000
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 41100000 41100001 
[phone] 41100002 
[phone] 41100003 
[phone] 41100001 41100004 
[phone] 41100000 41100005 
[phone] 41100006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 43100000 43100001 
[phone] 43100002 
[phone] 43100003 
[phone] 43100004 43100013 
[phone] 43100005 43100022 
[phone] 43100000 43100006 
[phone] 43100007 
[phone] 43100008 
[phone] 43100009 
[phone] 43100010 
[phone] 43100011 
[phone] 43100012 
[phone] 43100013 43100021 
[phone] 43100014 
[phone] 43100015 
[phone] 43100016 
[phone] 43100017 
[phone] 43100018 
[phone] 43100019 43100014 
[phone] 43100020 
[phone] 43100021 
[phone] 43100002 43100022 
[phone] 43100023 
[phone] 43100021 
+
+--------------------------------------------
[phone]
[phone] 10800001 
[phone] 10800000 10800002 
[phone] 10800002 
+
+--------------------------------------------
[phone]
[phone] 45700000 
+
+--------------------------------------------
[phone]
[phone] 15400001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 20000001 
[phone] 20000002 
[phone] 20000000 20000003 
[phone] 20000001 
+
+--------------------------------------------
[phone]
[phone] 24600000 24600001 
[phone] 24600002 
[phone] 24600000 24600003 
[phone] 24600000 24600004 
[phone] 24600005 
[phone] 24600002 24600006 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 29200000 29200001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 46000001 
[phone] 46000002 
[phone] 46000003 
[phone] 46000004 
[phone] 46000005 
[phone] 46000011 46000006 
[phone] 46000006 46000007 
[phone] 46000008 
[phone] 46000009 46000010 
[phone] 46000010 46000005 
[phone] 46000011 
[phone] 46000010 46000012 
[phone] 46000013 46000014 
[phone] 46000008 46000014 
[phone] 46000015 
[phone] 46000016 
[phone] 46000017 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 22600000 22600001 
[phone] 22600002 22600003 
[phone] 22600003 
[phone] 22600009 22600004 
[phone] 22600005 
[phone] 22600006 
[phone] 22600007 
[phone] 22600008 22600006 
[phone] 22600008 22600009 
[phone] 22600010 
[phone] 22600019 22600011 
[phone] 22600011 22600012 
[phone] 22600013 
[phone] 22600014 
[phone] 22600015 
[phone] 22600016 22600018 
[phone] 22600017 22600001 
[phone] 22600018 
[phone] 22600019 22600012 
[phone] 
+
+--------------------------------------------
+3500000
[phone] 
[phone] 3500002 
[phone] 3500003 
[phone] 3500004 
[phone] 3500005 
[phone] 
[phone] 3500007 
[phone] 3500000 
[phone] 
[phone] 3500020 
[phone] 
[phone] 3500012 
[phone] 
[phone] 3500014 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 38400000 38400001 
[phone] 38400002 
[phone] 38400003 
[phone] 38400004 
[phone] 
+
+--------------------------------------------
+8100000
[phone] 
[phone] 8100002 
[phone] 8100003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 43000001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 23900001 
[phone] 23900001 23900002 
[phone] 23900001 23900003 
[phone] 23900004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 47600000 47600001 
[phone] 47600002 
[phone] 47600003 
[phone] 47600002 47600004 
[phone] 47600005 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 17300000 17300001 
[phone] 17300002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 21900001 
[phone] 21900001 21900002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42500001 
[phone] 42500000 
+
+--------------------------------------------
[phone]
[phone] 26500001 26500004 
[phone] 26500002 
[phone] 26500000 26500003 
[phone] 26500003 26500004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 31100001 31100005 
[phone] 31100002 31100010 
[phone] 31100003 31100005 
[phone] 31100004 
[phone] 31100005 
[phone] 31100006 
[phone] 31100000 31100007 
[phone] 31100008 
[phone] 31100009 
[phone] 31100010 
[phone] 31100011 
[phone] 31100012 
[phone] 31100013 
[phone] 31100014 
[phone] 
+
+--------------------------------------------
+800000
[phone] 
[phone] 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 35700225 7100000 
[phone] 35700048 35700226 
[phone] 35700033 35700227 
[phone] 35700228 35700151 
[phone] 35700244 35700229 
[phone] 35700230 42900000 
[phone] 35700040 35700231 
[phone] 35700232 6000000 
[phone] 35700233 34900000 
[phone] 35700234 8200000 
[phone] 35700235 35700004 
[phone] 35700236 23800000 
[phone] 35700091 35700237 
[phone] 35700238 31200000 
[phone] 35700090 35700239 
[phone] 35700240 16000000 
[phone] 35700241 20400000 
[phone] 35700242 42000000 
[phone] 35700243 35700039 
[phone] 35700244 0 
[phone] 35700196 35700245 
[phone] 35700246 33400000 
[phone] 35700247 24200000 
[phone] 35700248 35700032 
[phone] 35700249 35700020 
[phone] 35700250 25700000 
[phone] 35700024 35700251 
[phone] 35700252 47400000 
[phone] 35700253 35700175 
[phone] 35700171 35700254 
[phone] 35700150 35700255 
[phone] 35700256 35700110 
[phone] 35700257 1100000 
[phone] 35700258 35700098 
[phone] 35700259 35700230 
[phone] 35700260 49700000 
[phone] 47000000 
[phone] 35700001 35700054 
[phone] 35700000 35700002 
[phone] 35700003 35700004 
[phone] 35700004 5100000 
[phone] 35700005 49400000 
[phone] 35700001 35700006 
[phone] 35700121 35700007 
[phone] 35700008 43300000 
[phone] 35700009 35700197 
[phone] 35700010 500000 
[phone] 35700011 35700006 
[phone] 35700012 42200000 
[phone] 35700226 35700013 
[phone] 35700010 35700014 
[phone] 35700012 35700015 
[phone] 35700016 800000 
[phone] 35700017 11900000 
[phone] 35700018 36100000 
[phone] 35700040 35700019 
[phone] 35700020 23300000 
[phone] 35700021 41300000 
[phone] 35700022 29600000 
[phone] 35700023 38200000 
[phone] 35700024 36400000 
[phone] 35700025 35700018 
[phone] 35700026 35700182 
[phone] 35700027 35700020 
[phone] 35700028 44000000 
[phone] 35700026 35700029 
[phone] 35700030 13600000 
[phone] 35700031 44300000 
[phone] 35700032 36600000 
[phone] 35700033 35700022 
[phone] 35700034 22100000 
[phone] 35700035 35700004 
[phone] 35700036 11800000 
[phone] 35700037 17400000 
[phone] 35700126 35700038 
[phone] 35700228 35700039 
[phone] 35700040 35700128 
[phone] 35700041 35700073 
[phone] 35700042 8800000 
[phone] 35700043 46100000 
[phone] 35700044 20700000 
[phone] 35700045 11400000 
[phone] 35700046 14700000 
[phone] 35700003 35700047 
[phone] 35700048 35700047 
[phone] 35700049 35700035 
[phone] 35700050 35700045 
[phone] 35700051 18700000 
[phone] 35700052 8300000 
[phone] 35700053 14600000 
[phone] 35700054 22400000 
[phone] 35700190 35700055 
[phone] 35700056 35700036 
[phone] 35700057 6900000 
[phone] 35700058 5600000 
[phone] 35700059 37000000 
[phone] 35700000 35700060 
[phone] 35700061 35700039 
[phone] 35700062 13000000 
[phone] 35700063 29400000 
[phone] 35700064 35700045 
[phone] 35700065 19900000 
[phone] 35700066 33300000 
[phone] 35700019 35700067 
[phone] 35700068 35700174 
[phone] 35700069 2300000 
[phone] 35700070 16400000 
[phone] 35700200 35700071 
[phone] 35700072 35700046 
[phone] 35700073 35700214 
[phone] 35700032 35700074 
[phone] 35700075 15400000 
[phone] 35700076 35700173 
[phone] 35700012 35700077 
[phone] 35700078 35700039 
[phone] 35700082 35700079 
[phone] 35700080 7000000 
[phone] 35700081 10800000 
[phone] 35700082 35700018 
[phone] 35700083 19800000 
[phone] 35700084 20000000 
[phone] 35700192 35700085 
[phone] 35700086 34700000 
[phone] 35700218 35700087 
[phone] 35700088 35700124 
[phone] 35700089 35700219 
[phone] 35700090 35700218 
[phone] 35700009 35700091 
[phone] 35700192 35700092 
[phone] 35700093 38100000 
[phone] 35700075 35700094 
[phone] 35700095 27000000 
[phone] 35700096 42600000 
[phone] 35700097 33900000 
[phone] 35700098 41900000 
[phone] 35700099 19000000 
[phone] 35700074 35700100 
[phone] 35700101 47500000 
[phone] 35700097 35700102 
[phone] 35700103 37400000 
[phone] 35700104 19600000 
[phone] 35700112 35700105 
[phone] 35700106 9900000 
[phone] 35700107 35700062 
[phone] 35700018 35700108 
[phone] 35700109 33200000 
[phone] 35700110 21800000 
[phone] 35700090 35700111 
[phone] 35700112 21400000 
[phone] 35700113 35700083 
[phone] 35700114 20600000 
[phone] 35700115 1900000 
[phone] 35700116 35700077 
[phone] 35700117 35200000 
[phone] 35700118 29800000 
[phone] 35700119 40400000 
[phone] 35700120 35700088 
[phone] 35700144 35700121 
[phone] 35700097 35700122 
[phone] 35700123 46500000 
[phone] 35700124 23200000 
[phone] 35700081 35700125 
[phone] 35700126 32300000 
[phone] 35700127 48600000 
[phone] 35700128 46600000 
[phone] 35700129 35700057 
[phone] 35700130 35700206 
[phone] 35700178 35700131 
[phone] 35700132 35700117 
[phone] 35700133 12300000 
[phone] 35700213 35700134 
[phone] 35700113 35700135 
[phone] 35700136 7600000 
[phone] 35700137 28100000 
[phone] 35700138 35700054 
[phone] 35700139 49200000 
[phone] 35700140 19500000 
[phone] 35700040 35700141 
[phone] 35700108 35700142 
[phone] 35700183 35700143 
[phone] 35700144 47900000 
[phone] 35700145 35700097 
[phone] 35700146 37900000 
[phone] 35700147 20100000 
[phone] 35700148 10200000 
[phone] 35700149 16300000 
[phone] 35700150 35700111 
[phone] 35700151 23600000 
[phone] 35700152 35700084 
[phone] 35700153 35700014 
[phone] 35700154 39700000 
[phone] 35700155 9800000 
[phone] 35700123 35700156 
[phone] 35700157 35700007 
[phone] 35700158 16800000 
[phone] 35700009 35700159 
[phone] 35700160 35700204 
[phone] 35700161 32900000 
[phone] 35700162 42800000 
[phone] 35700041 35700163 
[phone] 35700025 35700164 
[phone] 35700165 22600000 
[phone] 35700029 35700166 
[phone] 35700001 35700167 
[phone] 35700168 35700160 
[phone] 35700169 44100000 
[phone] 35700170 35700150 
[phone] 35700171 18600000 
[phone] 35700172 4800000 
[phone] 35700173 17500000 
[phone] 35700174 27800000 
[phone] 35700175 39500000 
[phone] 35700176 32600000 
[phone] 35700177 35700097 
[phone] 35700178 35700172 
[phone] 35700179 41000000 
[phone] 35700203 35700180 
[phone] 35700181 35700206 
[phone] 35700236 35700182 
[phone] 35700089 35700183 
[phone] 35700184 35700077 
[phone] 35700088 35700185 
[phone] 35700186 35700123 
[phone] 35700187 3000000 
[phone] 35700188 40200000 
[phone] 35700189 35700133 
[phone] 35700190 32800000 
[phone] 35700191 33000000 
[phone] 35700192 44800000 
[phone] 35700193 4700000 
[phone] 35700194 12000000 
[phone] 35700195 28500000 
[phone] 35700196 6500000 
[phone] 35700197 40500000 
[phone] 35700025 35700198 
[phone] 35700239 35700199 
[phone] 35700200 48800000 
[phone] 35700201 2700000 
[phone] 35700202 35700151 
[phone] 35700203 35700037 
[phone] 35700170 35700204 
[phone] 35700205 17300000 
[phone] 35700134 35700206 
[phone] 35700008 35700207 
[phone] 35700208 38500000 
[phone] 35700209 35700081 
[phone] 35700210 38400000 
[phone] 35700211 35700164 
[phone] 35700210 35700212 
[phone] 35700213 10900000 
[phone] 35700214 14200000 
[phone] 35700215 30300000 
[phone] 35700216 2500000 
[phone] 35700217 35700179 
[phone] 35700145 35700218 
[phone] 35700219 35700139 
[phone] 35700220 35700109 
[phone] 35700221 30800000 
[phone] 35700117 35700222 
[phone] 35700223 39000000 
[phone] 35700224 29500000 
+
+--------------------------------------------
+5400000
[phone] 42700000 
+
+--------------------------------------------
[phone]
[phone] 40300001 40300002 
[phone] 40300002 40300004 
[phone] 40300003 
[phone] 40300004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 10000001 
[phone] 10000002 
[phone] 10000002 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
[phone]
[phone] 39000001 39000002 
[phone] 39000002 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 19300001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 19200000 19200001 
[phone] 19200002 
[phone] 19200003 
[phone] 19200002 19200004 
[phone] 19200005 
[phone] 19200004 
+
+--------------------------------------------
[phone]
[phone] 23800000 23800001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 28400001 
[phone] 28400000 42600000 
+
+--------------------------------------------
[phone]
[phone] 33000001 
[phone] 
+
+--------------------------------------------
+2700000
[phone] 
[phone] 2700002 
[phone] 2700003 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 37600000 37600001 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 
+
+--------------------------------------------
+7300000
[phone] 
+
+--------------------------------------------
[phone]
[phone] 42200001 
[phone] 42200002 
[phone] 42200001 42200003 
[phone] 42200004 
[phone] 
+
+--------------------------------------------
[phone]
[phone] 11900001 
[phone] 11900002 
[phone] 11900001 11900003 
[phone] 11900001 11900004 
[phone] 11900002 11900005 
[phone] 11900004 
+
+--------------------------------------------
[phone]
[phone] 46800001 14100000 
[phone] 46800002 46800062 
[phone] 46800000 46800003 
[phone] 46800001 46800004 
[phone] 46800004 46800005 
[phone] 46800006 40300000 
[phone] 46800007 4500000 
[phone] 46800008 45800000 
[phone] 46800009 8700000 
[phone] 46800010 29000000 
[phone] 46800000 46800011 
[phone] 46800012 29900000 
[phone] 46800013 40100000 
[phone] 46800014 8000000 
[phone] 46800015 1400000 
[phone] 46800016 11500000 
[phone] 46800017 24900000 
[phone] 46800018 46800044 
[phone] 46800016 46800019 
[phone] 46800010 46800020 
[phone] 46800021 44900000 
[phone] 46800160 46800022 
[phone] 46800023 41200000 
[phone] 46800024 46800093 
[phone] 46800025 45200000 
[phone] 46800026 2600000 
[phone] 46800010 46800027 
[phone] 46800028 7900000 
[phone] 46800029 32500000 
[phone] 46800026 46800030 
[phone] 46800031 24100000 
[phone] 46800032 43900000 
[phone] 46800033 46800004 
[phone] 46800034 31100000 
[phone] 46800035 46800005 
[phone] 46800036 27700000 
[phone] 46800037 42100000 
[phone] 46800038 25300000 
[phone] 46800039 8500000 
[phone] 46800040 26800000 
[phone] 46800041 45500000 
[phone] 46800042 46800015 
[phone] 46800043 8600000 
[phone] 46800044 46800021 
[phone] 46800024 46800045 
[phone] 46800147 46800046 
[phone] 46800038 46800047 
[phone] 46800048 46800069 
[phone] 46800049 12100000 
[phone] 46800050 46800045 
[phone] 46800051 
[phone] 46800052 48200000 
[phone] 46800057 46800053 
[phone] 46800034 46800054 
[phone] 46800005 46800055 
[phone] 46800056 46800132 
[phone] 46800057 13900000 
[phone] 46800058 30700000 
[phone] 46800059 46800043 
[phone] 46800060 25500000 
[phone] 46800124 46800061 
[phone] 46800034 46800062 
[phone] 46800063 38700000 
[phone] 46800064 38300000 
[phone] 46800065 28000000 
[phone] 46800066 39200000 
[phone] 46800066 46800067 
[phone] 46800067 46800068 
[phone] 46800048 46800069 
[phone] 46800012 46800070 
[phone] 46800007 46800071 
[phone] 46800072 44200000 
[phone] 46800073 41800000 
[phone] 46800074 46800071 
[phone] 46800075 46800030 
[phone] 46800076 7200000 
[phone] 46800066 46800077 
[phone] 46800078 9600000 
[phone] 46800010 46800079 
[phone] 46800080 46800064 
[phone] 46800081 35700000 
[phone] 46800082 32200000 
[phone] 46800083 38600000 
[phone] 46800084 7700000 
[phone] 46800085 16500000 
[phone] 46800059 46800086 
[phone] 46800113 46800087 
[phone] 46800088 12400000 
[phone] 46800089 11200000 
[phone] 46800090 44600000 
[phone] 46800098 46800091 
[phone] 46800092 1000000 
[phone] 46800093 14500000 
[phone] 46800075 46800094 
[phone] 46800074 46800095 
[phone] 46800096 46800016 
[phone] 46800097 46800042 
[phone] 46800098 13800000 
[phone] 46800099 4200000 
[phone] 46800100 9300000 
[phone] 46800101 15200000 
[phone] 46800102 22800000 
[phone] 46800103 20900000 
[phone] 46800104 46800070 
[phone] 46800105 25400000 
[phone] 46800040 46800106 
[phone] 46800107 46300000 
[phone] 46800108 39900000 
[phone] 46800042 46800109 
[phone] 46800110 40000000 
[phone] 46800106 46800111 
[phone] 46800112 39600000 
[phone] 46800113 46800090 
[phone] 46800114 46800086 
[phone] 46800115 
[phone] 46800017 46800116 
[phone] 46800117 49000000 
[phone] 46800118 200000 
[phone] 46800050 46800119 
[phone] 46800120 46800067 
[phone] 46800121 
[phone] 46800122 18100000 
[phone] 46800123 46800070 
[phone] 46800124 19300000 
[phone] 46800059 46800125 
[phone] 46800126 45100000 
[phone] 46800005 46800127 
[phone] 46800128 30400000 
[phone] 46800129 46800126 
[phone] 46800130 46800101 
[phone] 46800131 12800000 
[phone] 46800132 40600000 
[phone] 46800065 46800133 
[phone] 46800134 12200000 
[phone] 46800127 46800135 
[phone] 46800136 49600000 
[phone] 46800137 46800097 
[phone] 46800025 46800138 
[phone] 46800139 6100000 
[phone] 46800140 46800119 
[phone] 46800136 46800141 
[phone] 46800142 23700000 
[phone] 46800143 47800000 
[phone] 46800144 25000000 
[phone] 46800145 4000000 
[phone] 46800146 24500000 
[phone] 46800147 46800067 
[phone] 46800148 28600000 
[phone] 46800011 46800149 
[phone] 46800134 46800150 
[phone] 46800137 46800151 
[phone] 46800152 46800124 
[phone] 46800024 46800153 
[phone] 46800154 24300000 
[phone] 46800155 4100000 
[phone] 46800115 46800156 
[phone] 46800000 46800157 
[phone] 46800158 13700000 
[phone] 46800159 9500000 
[phone] 46800160 10300000 
[phone] 46800161 4300000 
[phone] 46800008 46800162 
[phone] 46800163 22900000 
[phone] 46800164 35500000 
[phone] 46800080 46800165 
[phone] 28800000 
+
+--------------------------------------------
[phone]
[phone] 16500000 
+
+--------------------------------------------
[phone]
[phone] 21100000 21100001 
[phone] 21100002 
[phone] 21100000 
+
+--------------------------------------------
[phone]
[phone] 25700001 
[phone] 25700000 25700002 
[phone] 25700003 
[phone] 
+
+--------------------------------------------
+SYSTEM CALLS 
+
[phone] label_363
+1 label_362
[phone] label_9
[phone] label_78
+5 label_359
+6400007 label_147
[phone] label_328
+4600000 label_185
[phone] label_49
[phone] label_14
+3 label_108
+4 label_173
+6400005 label_161
[phone] label_294
[phone] label_356
[phone] label_123
[phone] label_231
[phone] label_205
[phone] label_53
[phone] label_337
[phone] label_60
[phone] label_348
[phone] label_106
[phone] label_263
[phone] label_250
[phone] label_259
[phone] label_271
[phone] label_176
+8700001 label_299
[phone] label_327
[phone] label_66
+3800000 label_60
+9500006 label_60
+8700012 label_172
+5200000 label_309
[phone] label_310
[phone] label_214
[phone] label_44
[phone] label_79
[phone] label_258
[phone] label_54
[phone] label_117
[phone] label_184
[phone] label_88
[phone] label_319
[phone] label_300
+1700005 label_137
+9500018 label_261
[phone] label_203
[phone] label_238
[phone] label_237
[phone] label_152
[phone] label_391
+4600003 label_59
[phone] label_136
[phone] label_210
+9300002 label_259
[phone] label_250
[phone] label_173
[phone] label_219
[phone] label_150
[phone] label_95
[phone] label_179
[phone] label_385
[phone] label_215
[phone] label_318
[phone] label_142
[phone] label_314
[phone] label_56
[phone] label_395
[phone] label_102
[phone] label_229
[phone] label_88
[phone] label_253
[phone] label_83
+6900003 label_281
+6900004 label_287
[phone] label_158
+6900006 label_14
[phone] label_154
[phone] label_82
[phone] label_211
[phone] label_243
[phone] label_132
[phone] label_221
[phone] label_307
[phone] label_24
[phone] label_240
[phone] label_10
[phone] label_396
[phone] label_310
[phone] label_176
[phone] label_13
[phone] label_240
+4100001 label_227
[phone] label_163
[phone] label_283
[phone] label_36
[phone] label_103
[phone] label_167
[phone] label_257
[phone] label_118
+4100002 label_15
+9200000 label_66
[phone] label_180
[phone] label_133
+2800003 label_122
[phone] label_270
[phone] label_193
[phone] label_207
[phone] label_285
[phone] label_374
[phone] label_11
[phone] label_251
+5700004 label_125
[phone] label_156
[phone] label_107
[phone] label_146
+5700008 label_268
[phone] label_195
[phone] label_364
[phone] label_13
[phone] label_166
+8600002 label_119
[phone] label_224
+8900002 label_87
+5700003 label_54
[phone] label_290
[phone] label_129
[phone] label_69
[phone] label_245
[phone] label_334
[phone] label_218
[phone] label_303
[phone] label_182
[phone] label_319
+1600001 label_27
[phone] label_333
[phone] label_132
[phone] label_375
+5600002 label_5
[phone] label_394
[phone] label_154
[phone] label_151
[phone] label_259
[phone] label_248
[phone] label_221
+4500000 label_121
[phone] label_18
[phone] label_350
[phone] label_336
[phone] label_264
[phone] label_188
[phone] label_65
[phone] label_326
[phone] label_295
+7400002 label_341
+7400003 label_113
+1000005 label_303
+1000007 label_246
[phone] label_131
+2500003 label_398
[phone] label_370
[phone] label_360
[phone] label_252
[phone] label_331
[phone] label_36
[phone] label_351
[phone] label_362
+1700001 label_43
+7900007 label_81
[phone] label_304
[phone] label_26
[phone] label_47
+5500011 label_343
[phone] label_137
+6800005 label_52
+8600001 label_114
[phone] label_210
+6800009 label_122
+6800010 label_116
[phone] label_83
[phone] label_334
[phone] label_381
[phone] label_245
[phone] label_286
[phone] label_224
[phone] label_154
[phone] label_235
+6200001 label_213
[phone] label_21
[phone] label_334
[phone] label_231
[phone] label_357
[phone] label_240
[phone] label_212
[phone] label_319
[phone] label_44
[phone] label_348
[phone] label_191
[phone] label_273
[phone] label_225
[phone] label_314
[phone] label_309
[phone] label_155
[phone] label_208
[phone] label_349
+5600008 label_389
+5600011 label_143
[phone] label_339
[phone] label_23
[phone] label_54
+2100002 label_276
+5500004 label_323
+2100005 label_313
+2100007 label_74
[phone] label_162
[phone] label_83
[phone] label_358
[phone] label_58
[phone] label_312
[phone] label_16
[phone] label_396
+5000018 label_3
[phone] label_384
[phone] label_324
[phone] label_165
[phone] label_124
+7900001 label_140
[phone] label_331
[phone] label_85
[phone] label_38
[phone] label_20
[phone] label_380
[phone] label_78
[phone] label_171
[phone] label_392
[phone] label_153
[phone] label_7
[phone] label_159
[phone] label_287
[phone] label_128
[phone] label_134
[phone] label_239
+1500000 label_48
[phone] label_198
[phone] label_217
[phone] label_244
[phone] label_120
[phone] label_95
[phone] label_288
[phone] label_45
[phone] label_38
[phone] label_68
[phone] label_79
[phone] label_157
[phone] label_304
+3800003 label_278
+3800005 label_344
[phone] label_399
+3800007 label_379
[phone] label_99
[phone] label_199
[phone] label_22
[phone] label_165
[phone] label_139
[phone] label_48
[phone] label_184
[phone] label_384
[phone] label_135
[phone] label_218
[phone] label_254
[phone] label_256
[phone] label_24
[phone] label_207
[phone] label_175
[phone] label_355
[phone] label_154
[phone] label_155
+5000001 label_338
[phone] label_339
[phone] label_118
[phone] label_343
[phone] label_30
[phone] label_299
[phone] label_80
[phone] label_90
[phone] label_274
[phone] label_383
[phone] label_108
[phone] label_109
[phone] label_377
[phone] label_67
[phone] label_308
[phone] label_353
[phone] label_59
[phone] label_296
[phone] label_301
[phone] label_371
[phone] label_10
[phone] label_322
+8800000 label_194
[phone] label_111
[phone] label_105
[phone] label_334
[phone] label_387
[phone] label_172
[phone] label_134
[phone] label_178
[phone] label_199
[phone] label_78
[phone] label_289
+4700003 label_378
[phone] label_390
[phone] label_222
+5500002 label_367
[phone] label_297
[phone] label_86
[phone] label_21
[phone] label_315
[phone] label_69
[phone] label_206
+8800002 label_218
+2000000 label_347
+8400001 label_84
[phone] label_252
+8400003 label_191
[phone] label_319
[phone] label_31
[phone] label_42
[phone] label_334
[phone] label_147
[phone] label_28
[phone] label_386
[phone] label_85
[phone] label_302
[phone] label_376
[phone] label_272
[phone] label_37
[phone] label_372
[phone] label_337
[phone] label_12
[phone] label_35
[phone] label_163
[phone] label_64
[phone] label_215
[phone] label_310
[phone] label_364
[phone] label_88
[phone] label_267
[phone] label_291
+7800002 label_255
[phone] label_110
[phone] label_40
[phone] label_350
[phone] label_135
[phone] label_87
[phone] label_330
[phone] label_4
[phone] label_293
[phone] label_100
[phone] label_264
[phone] label_247
[phone] label_252
[phone] label_177
[phone] label_290
[phone] label_126
[phone] label_214
+4300001 label_363
[phone] label_361
[phone] label_108
[phone] label_93
[phone] label_201
[phone] label_233
[phone] label_1
[phone] label_313
[phone] label_223
[phone] label_115
[phone] label_344
[phone] label_43
[phone] label_39
[phone] label_226
[phone] label_100
+7200004 label_279
[phone] label_233
[phone] label_161
[phone] label_227
[phone] label_362
[phone] label_281
[phone] label_230
+7200013 label_161
[phone] label_358
[phone] label_378
+700003 label_117
+7200020 label_183
[phone] label_200
[phone] label_238
[phone] label_347
[phone] label_70
[phone] label_391
[phone] label_283
[phone] label_375
[phone] label_203
+3700006 label_200
[phone] label_245
[phone] label_174
[phone] label_26
[phone] label_280
[phone] label_167
[phone] label_192
+6600002 label_66
[phone] label_204
[phone] label_17
[phone] label_105
[phone] label_141
[phone] label_89
[phone] label_50
[phone] label_65
[phone] label_307
[phone] label_23
+9500002 label_152
[phone] label_328
+9500008 label_51
[phone] label_209
+9500015 label_165
[phone] label_340
[phone] label_244
[phone] label_397
[phone] label_370
[phone] label_205
[phone] label_48
[phone] label_242
[phone] label_188
[phone] label_303
[phone] label_149
[phone] label_40
[phone] label_178
[phone] label_321
[phone] label_35
[phone] label_19
[phone] label_363
[phone] label_172
[phone] label_316
[phone] label_279
[phone] label_331
[phone] label_121
[phone] label_165
+9900000 label_171
[phone] label_222
+2500002 label_242
+8900003 label_131
[phone] label_324
[phone] label_270
[phone] label_155
[phone] label_321
[phone] label_367
[phone] label_177
[phone] label_206
[phone] label_130
[phone] label_333
[phone] label_263
[phone] label_237
+5400000 label_148
[phone] label_235
[phone] label_29
[phone] label_219
[phone] label_393
[phone] label_394
[phone] label_168
[phone] label_253
[phone] label_120
[phone] label_293
[phone] label_113
[phone] label_382
[phone] label_105
[phone] label_219
+8300003 label_237
[phone] label_139
[phone] label_335
[phone] label_95
[phone] label_265
[phone] label_21
[phone] label_251
[phone] label_100
[phone] label_152
[phone] label_167
[phone] label_285
[phone] label_380
[phone] label_226
[phone] label_150
[phone] label_52
[phone] label_198
+7200003 label_25
[phone] label_379
[phone] label_56
+1300000 label_310
[phone] label_150
[phone] label_387
[phone] label_354
[phone] label_76
[phone] label_186
[phone] label_89
[phone] label_122
[phone] label_35
[phone] label_55
[phone] label_174
[phone] label_16
[phone] label_1
[phone] label_260
[phone] label_145
[phone] label_317
[phone] label_2
+700004 label_146
+700006 label_396
[phone] label_288
[phone] label_305
[phone] label_12
[phone] label_78
[phone] label_312
+9400004 label_326
[phone] label_342
[phone] label_68
[phone] label_153
+3600002 label_329
[phone] label_197
[phone] label_55
[phone] label_352
[phone] label_238
[phone] label_295
[phone] label_158
[phone] label_170
[phone] label_376
[phone] label_396
[phone] label_96
[phone] label_304
[phone] label_132
[phone] label_292
[phone] label_117
[phone] label_50
[phone] label_87
[phone] label_375
[phone] label_272
[phone] label_37
[phone] label_107
[phone] label_38
[phone] label_71
[phone] label_368
[phone] label_201
[phone] label_222
+3000004 label_261
[phone] label_332
[phone] label_161
+7200016 label_337
[phone] label_282
[phone] label_190
[phone] label_48
[phone] label_368
[phone] label_57
[phone] label_169
[phone] label_399
+5900003 label_268
[phone] label_216
[phone] label_371
[phone] label_222
+5900010 label_272
[phone] label_345
+5900013 label_135
[phone] label_4
[phone] label_58
+500008 label_70
[phone] label_373
[phone] label_137
[phone] label_254
+2400000 label_143
[phone] label_12
[phone] label_22
[phone] label_98
[phone] label_341
[phone] label_391
[phone] label_232
[phone] label_339
[phone] label_269
[phone] label_21
[phone] label_254
[phone] label_121
[phone] label_162
[phone] label_241
[phone] label_352
[phone] label_202
[phone] label_92
+6300006 label_388
[phone] label_81
[phone] label_182
[phone] label_382
[phone] label_32
[phone] label_217
[phone] label_346
[phone] label_141
[phone] label_346
[phone] label_176
[phone] label_199
[phone] label_154
+8200003 label_374
[phone] label_46
[phone] label_340
[phone] label_15
[phone] label_231
[phone] label_325
[phone] label_249
[phone] label_245
[phone] label_137
[phone] label_202
+4700000 label_91
[phone] label_394
[phone] label_314
[phone] label_389
+4700004 label_76
[phone] label_323
[phone] label_129
[phone] label_234
[phone] label_377
[phone] label_19
[phone] label_55
[phone] label_123
[phone] label_373
[phone] label_364
[phone] label_159
[phone] label_114
[phone] label_249
[phone] label_298
[phone] label_332
[phone] label_307
+3400001 label_77
[phone] label_39
[phone] label_197
[phone] label_353
[phone] label_358
[phone] label_284
[phone] label_310
[phone] label_30
[phone] label_177
[phone] label_320
[phone] label_368
[phone] label_281
+4100000 label_21
[phone] label_354
[phone] label_369
[phone] label_44
[phone] label_69
[phone] label_120
[phone] label_386
[phone] label_87
[phone] label_179
[phone] label_354
[phone] label_168
[phone] label_164
[phone] label_212
[phone] label_312
[phone] label_164
[phone] label_266
[phone] label_306
[phone] label_159
[phone] label_58
[phone] label_105
[phone] label_360
[phone] label_346
[phone] label_326
[phone] label_35
[phone] label_236
[phone] label_250
[phone] label_158
[phone] label_295
[phone] label_64
[phone] label_366
[phone] label_308
[phone] label_102
+3500004 label_196
+9900005 label_382
+3500006 label_261
[phone] label_355
[phone] label_275
[phone] label_311
+3500021 label_88

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/node.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * node.h
+ *
+ *  Created on: Feb 1, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#ifndef NODE_H_
+#define NODE_H_
+
+
+
+
+/* --------
+ * Nodes are the basic data structure within the graph. Nodes hold information
+ * regarding their identity (id, label, type, etc.) and information about their
+ * edges (list of edges, number of edges).
+ *
+ * Node.h/.c contains the data definitions for nodes and edges as well as con-
+ * tainers for nodes (NodeList, NodePtrVec) and edges (EdgeList)
+ */
+
+
+
+
+typedef enum
+{
+    exteriorNode, /* Default unless Node_setParent is called */
+    interiorNode,
+    entranceNode  /* special interior node(s) that begin the interior graph */
+} NodeType;
+
+
+/* -------------------------------------------
+ * Node Definitions
+ *
+ */
+
+
+
+typedef struct NodeStruct Node;
+typedef struct NodeListStruct NodeList;
+typedef struct EdgeListStruct EdgeList;
+
+#include "bitfield.h"
+#include "vectorUtils.h"
+#include <stdbool.h>
+
+struct NodeStruct
+{
+    int id; /* id value for the node - typically associated with an address of the basic block */
+    int nodeCount; /* a unique index for this node (0 .. whatever) */
+    char *label;
+    int labelIdx;
+    NodeType type;
+    Node *container; /* if this is an interior node, this points to the outer node containing this one */
+    NodeList *interiorNodes; /* All the nodes contained in this node's subgraph */
+    EdgeList *edges; /* Nodes that can be accessed from this node (includes entrance nodes) */
+
+    int edgeCount; /* edges from this node to others (DOES NOT INLCUDE INTRANCE NODES) */
+    int entranceCount; /* number of entrance nodes (if any) */
+};
+
+/* "methods" for nodes */
+
+Node *Node_new( int id, int nodeCount );    /* Constructor */
+void Node_delete( Node *trash ); /* Destructor */
+Node *Node_duplicate(Node *from, int newIndex); /* Duplicates node data, BUT NO EDGE INFORMATION */
+void Node_setParent( Node *this, Node *parent );  /* Identifies the Upper-level node containing inner level node */
+void Node_addInteriorNode( Node *this, Node *interior ); /* Inserts interior node into parent list */
+bool Node_addEdgeToNode(Node *this, Node *node); /* Node* based insertion method */
+
+
+/* -------------------------------------------
+ * Node List Definitions
+ *
+ */
+
+struct NodeListStruct
+{
+    Node *node;
+    NodeList *nextNode;
+};
+
+/* "methods" for NodeLists */
+
+NodeList *NodeList_new(); /* Constructor */
+
+/* Destructor - also frees the data allocated for nodes if freeMemory is
+ * true (calls their "destructor )
+ */
+void NodeList_clear( NodeList *trash, bool deleteNodes );
+
+/* insertFront modifies the list passed in such that the first element
+ * points to the new node. This is done by duplicating the first element
+ * into a new element, and then modifying the true first element to point
+ * to the node passed and and the created element (which references the
+ * rest of the list).
+ */
+bool NodeList_insertFront( NodeList *this, Node *newFront );
+/* Create a new node list element, have it reference the node passed in
+ * and then put it in the back of the list. Returns true on success
+ */
+bool NodeList_insertBack( NodeList *this, Node *newBack );
+
+/* -------------------------------------------
+ * Edge List Definitions
+ *
+ *     Edges are processed a little differently than nodes. As soon as a
+ *     node is identified, it is created. However, the edges may be
+ *     identified prior to the creation of the node to which it references.
+ *     Ergo, there's a two pass process - first identifying the edges,
+ *     then subsequently setting the pointers to reference them.
+ *
+ *     Rather than making a dual structure "Edge" and "EdgeList" pair,
+ *     the author is combining the data into a single structure.
+ */
+
+struct EdgeListStruct
+{
+    int targetNodeId;
+    Node *targetNode;
+    EdgeList *nextEdge;
+};
+
+EdgeList *EdgeList_new(); /* Constructor */
+void EdgeList_clear(EdgeList* this); /* Destructor */
+bool EdgeList_insertNodeId(EdgeList *this, int targetNodeId); /* Id based insertion method */
+
+#endif /* NODE_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/node.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * node.c
+ *
+ *  Created on: Feb 1, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+/* --------
+ * Nodes are the basic data structure within the graph. Nodes hold information
+ * regarding their identity (id, label, type, etc.) and information about their
+ * edges (list of edges, number of edges).
+ *
+ * Node.h/.c contains the data definitions for nodes and edges as well as con-
+ * tainers for nodes (NodeList, NodePtrVec) and edges (EdgeList)
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "node.h"
+#include "graph.h"
+
+
+/* -------------------------------------------
+ * Node Method Definitions
+ *
+ */
+
+/* "methods" for nodes */
+/* Constructor */
+Node *Node_new(int id, int nodeCount)
+{
+    Node *node = malloc(sizeof(Node));
+
+    if ( !node )
+        return(NULL);
+
+    node->id = id;
+    node->nodeCount = nodeCount; /* index into bitfield - caller must increment! */
+    node->label = NULL;
+    node->labelIdx = -1;
+    node->type = exteriorNode;
+    node->container = NULL;
+    node->interiorNodes = NULL;
+    node->edges = NULL;
+
+    node->edgeCount = 0;
+    node->entranceCount = 0;
+
+    return(node);
+}
+
+/* Destructor */
+void Node_delete(Node *trash)
+{
+    /* Some basic error checking */
+    if ( !trash ) return;
+
+    if ( trash->interiorNodes ) /* "true" tells clearNodeList to free the mallocs */
+        NodeList_clear( trash->interiorNodes, true );
+
+    if ( trash->edges )
+        EdgeList_clear( trash->edges );
+
+    free( trash );
+}
+
+/* Duplicates node data, BUT NO EDGE INFORMATION */
+Node *Node_duplicate(Node *from, int newIndex)
+{
+    Node *copy = malloc(sizeof(Node));
+
+    if ( !copy || !from )
+        return(NULL);
+
+    copy->id = from->id;
+    copy->nodeCount = newIndex; /* index into bitfield - caller must increment! */
+    copy->label = from->label;
+    copy->labelIdx = from->labelIdx;
+    copy->type = from->type;
+    copy->container = NULL;
+    copy->interiorNodes = NULL;
+    copy->edges = NULL;
+
+    copy->edgeCount = 0;
+    copy->entranceCount = 0;
+
+    return(copy);
+}
+
+/* Identifies the Upper-level node containing inner level node */
+void Node_setParent(Node *this, Node *parent)
+{
+    /* Some basic error checking */
+    if ( !this || !parent )
+        return;
+
+    this->container = parent;
+    this->type = interiorNode;
+}
+
+/* Inserts interior node into parent list */
+void Node_addInteriorNode(Node *this, Node *interior)
+{
+    /* some basic error checking */
+    if ( !this || !interior )
+        return;
+
+    if ( this->interiorNodes == NULL )
+    {
+        this->interiorNodes = NodeList_new();
+        if ( this->interiorNodes == NULL )
+            return; /* malloc failed */
+        this->interiorNodes->node = interior;
+    }
+    else
+        NodeList_insertBack(this->interiorNodes, interior);
+
+    Node_setParent(interior, this);
+    return;
+}
+
+
+/* adds an edge from "this" to "node. If an allocation error occurs
+ * this method returns false. If an edge already exists, the method
+ * will NOT add a duplicate edge, and will return true.
+ */
+bool Node_addEdgeToNode(Node *this, Node *node)
+{
+    EdgeList *end = NULL;
+    EdgeList *newEdge = NULL;
+
+    if ( !this || !node )
+        return(false);
+
+    /* Scream through the list and make sure edge doesn't already exist */
+    for ( end = this->edges; end != NULL; end = end->nextEdge )
+        if ( end->targetNode == node )
+            return true;
+
+    /* Otherwise, we have a new edge. Insert it at the head of the list */
+    newEdge = EdgeList_new();
+    if ( !newEdge ) /* allocation error */
+        return false;
+    newEdge->targetNode = node;
+    newEdge->targetNodeId = node->id;
+    newEdge->nextEdge = this->edges; /* First time, this is NULL, terminates our list. */
+    this->edges = newEdge;
+    ++this->edgeCount;
+    return(true);
+}
+
+
+/* -------------------------------------------
+ * NodeList Method Definitions
+ *
+ */
+
+/* Constructor */
+NodeList * NodeList_new()
+{
+    NodeList *list = malloc(sizeof(NodeList));
+
+    if ( !list )
+        return(NULL);
+
+    list->node = NULL;
+    list->nextNode = NULL;
+
+    return(list);
+}
+
+/* Destructor - also frees the data allocated for nodes if freeMemory is
+ * true (calls their "destructor )
+ */
+void NodeList_clear(NodeList *trash, bool deleteNodes)
+{
+    /* Some basic error checking */
+    if ( !trash ) return;
+
+    if ( trash->nextNode )
+        NodeList_clear(trash->nextNode, deleteNodes);
+
+    if ( deleteNodes )
+    {
+        Node_delete(trash->node);
+    }
+    free(trash);
+}
+
+/* insertFront modifies the list passed in such that the first element
+ * points to the new node. This is done by duplicating the first element
+ * into a new element, and then modifying the true first element to point
+ * to the node passed and and the created element (which references the
+ * rest of the list).
+ */
+bool NodeList_insertFront(NodeList *this, Node *newFront)
+{
+    /* Make a new element that holds the information that used to
+     * be at the front.
+     */
+    NodeList *oldFront = NodeList_new();
+
+    /* Some basic error checking */
+    if ( !this || !newFront || !oldFront )
+        return(false);
+
+    /* move the formerly front data to the new element */
+    oldFront->node = this->node;
+    oldFront->nextNode = this->nextNode; /* Now points to the remainder of the list (or NULL) */
+
+    /* And change the head element to reference the new front node. */
+    this->node = newFront;
+    this->nextNode = oldFront;
+
+    return(true);
+}
+
+/* Create a new node list element, have it reference the node passed in
+ * and then put it in the back of the list. Returns true on success
+ */
+bool NodeList_insertBack(NodeList *this, Node *newBack)
+{
+    NodeList *end;
+    NodeList *newElement;
+
+    /* Some basic error checking */
+    if ( !this || !newBack )
+        return(false);
+
+    /* If the node portion of "this" is null,
+     * then we're starting with an empty list.
+     */
+
+    if ( this->node == NULL )
+    {
+        this->node = newBack;
+        return(true); /* We're done! */
+    }
+
+    /* Otherwise, we need to find the end of the list */
+    for ( end = this; end->nextNode != NULL; end = end->nextNode )
+    { /* No-op */ }
+
+    newElement = NodeList_new();
+    if ( !newElement )
+        return(false);
+
+    newElement->node = newBack;
+    end->nextNode = newElement; /* new nodelist element has a null next */
+
+    return(true);
+}
+
+
+
+
+
+/* -------------------------------------------
+ * Edge List Method Definitions
+ *
+ */
+
+/* Constructor */
+EdgeList *EdgeList_new()
+{
+    EdgeList *newNode = malloc( sizeof( struct EdgeListStruct ));
+    if ( newNode )
+    {
+        newNode->targetNodeId = -1; /* Potentially a bug. what if there's a node named -1? */
+        newNode->targetNode = NULL;
+        newNode->nextEdge = NULL;
+    }
+    return(newNode);
+}
+
+/* Destructor */
+void EdgeList_clear( EdgeList *this )
+{
+    /* Some basic error checking */
+    if ( !this )
+        return;
+
+    if ( this->nextEdge )
+        EdgeList_clear(this->nextEdge);
+
+    free(this);
+}
+
+/* Insertion Method
+ *     It is important to realize that this inserts the edge as an Id, it does
+ *     not find or initialize the node specified by that Id. That has to be
+ *     done as a separate step later.
+ */
+bool EdgeList_insertNodeId(EdgeList *this, int targetNodeId)
+{
+    EdgeList *end;
+    EdgeList *newElement;
+
+    /* some basic error checking */
+    if ( !this )
+        return(false);
+
+    /* Check to see if this is the initial insertion into the
+     * Edge list
+     */
+    if ( this->targetNodeId == -1 )
+    {
+        this->targetNodeId = targetNodeId;
+        return(true);
+    }
+
+    /* Otherwise we find the end of the list and make a new entry */
+    for ( end = this; end->nextEdge != NULL; end = end->nextEdge )
+    { /* No-op */ }
+
+    newElement = EdgeList_new();
+    if ( !newElement )
+        return(false);
+
+    newElement->targetNodeId = targetNodeId;
+    end->nextEdge = newElement; /* new edge list element has a null node and next */
+
+    return(true);
+}
+
+
+
+
+
+
+
+
+
+/* Search Algorithms */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/parsing.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+ 
+/*
+ * parsing.h
+ *
+ *  Created on: Jan 9, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+/* --------
+ * This pair of files contains the utility data types and methods for
+ * parsing data files into graphs. It also defines a "configuration"
+ * for a given run of PathFinder. The configuration holds all the info
+ * corresponding to the run - graphs, signatures, search types.
+ */
+
+#ifndef PARSING_H_
+#define PARSING_H_
+
+#include "vectorUtils.h"
+
+/* Since we're parsing into graphs, we need to know what they are... */
+#include "graph.h"
+#include "configuration.h"
+
+
+
+/* buildEntranceList takes an array of integers, and builds a
+ * non-resolved edge list from the array. This is a special
+ * edge list, used only be outer nodes to identify entrance
+ * points into their subgraph.
+ */
+void buildEntranceList( Node *outerNode, IntVector *nodeData );
+
+
+/* buildNodeFromData takes the integer array built by the above
+ * method, and creates a node from it. If that node has
+ * edge data, that is also built. The data is in an array,
+ * the size of which is also passed in.
+ */
+Node *buildNodeFromData( IntVector *nodeData );
+
+
+/* resolveNodeEdges is the second pass through the graph data
+ * structures. The first pass defines the nodes, and puts the edge
+ * ids in place. The second pass finds the nodes corresponding to
+ * the edge id, and sets the edge pointer to that node. Edges for
+ * outer nodes will only reference other outer nodes. Interior
+ * nodes may have edges to outer nodes or other interior nodes of
+ * their containing node. If an edge references an undefined node
+ * or if an edge goes into the interior of another outer node,
+ * the user will be notified.
+ */
+void resolveNodeEdges( Graph *graph, Node *sourceNode, bool outerNode );
+
+
+
+/* parseFile goes through the specified file to build the graph. It
+ * returns true if everything goes as planned. Any errors will cause
+ * false to be returned. The built graph can be accessed via
+ * Graph_the().
+ */
+
+Graph *parseFile( char *fileName );
+
+/* parseSignature takes a space delimited string and turns it
+ * into a "signature" - a packed array of c-string pointers with
+ * a NULL pointer to signify completion. As with our edge parser
+ * the code depends on a space character to terminate the line.
+ */
+char **parseSignature( char *data );
+
+/* parseConfigFile reads the data file names and desired search
+ * signatures from the config file. It returns a packed array
+ * of Graph pointers populated corresponding to the data files.
+ * Also, it returns a packed array of pointers to signatures.
+ * (Signatures are themselves packed arrays to C-Strings.) These
+ * packed arrays are terminated with a NULL pointer. They
+ * are returned in the "graphs" and "signatures" parameters
+ * which should be references to the desired pointers. See main.c.
+ */
+bool parseConfigFile( char *configFileName, Configuration *config );
+
+
+
+#endif /* PARSING_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/parsing.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+ 
+/*
+ * graph.c
+ *
+ *  Created on: Jan 9, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#include "parsing.h"
+#include "graph.h"
+#include "utils.h"
+#include "systemCallMap.h"
+#include "yaml.h"
+
+
+#include <ctype.h>
+
+
+/* buildEntranceList takes an array of integers, and builds a
+ * non-resolved edge list from the array. This is a special
+ * edge list, used only be outer nodes to identify entrance
+ * points into their subgraph. Only the edge data is passed in,
+ * this begins with the second entry (index 1) in the parsed
+ * data array. Likewise the size only counts edges.
+ *
+ * Initially, entrance transitions were handled as a separate
+ * list of edges. After further analysis, however, there is
+ * no operational difference between outer edges and entrance
+ * edges. Ergo, we are modifying this code to put the entrance
+ * edges into the edge list and deprecating the entrance list.
+ * The code is being left in for the time being as comments,
+ * since there are some contextual significances to interior
+ * nodes and entrance edges that may later be required. Otherwise
+ * we could go to a simple flat graph.
+ */
+void buildEntranceList( Node *outerNode, IntVector *nodeData )
+{
+    int i;
+    int entranceCount;
+
+    /* some basic error checking */
+    if ( !outerNode || !nodeData ) return;
+
+    entranceCount = nodeData->vector[1]; /* count is the first entry, (second of original data); */
+    if ( entranceCount == 0 )
+        return; /* Nothing to see here, folks */
+
+    if ( entranceCount != nodeData->size-2 )
+    {
+        fprintf ( stderr, "Specified entrance edge length does not match data size for node: %d\n",
+                outerNode->id );
+    }
+
+    /* Deprecated: outerNode->entranceNodes = EdgeList_new(); */
+    /* Deprecated: if ( outerNode->entranceNodes ) */
+    if ( !outerNode->edges )
+        outerNode->edges = EdgeList_new();
+    if ( outerNode->edges )
+        for ( i = 2; i < nodeData->size; ++i )
+        {
+            /* Deprecated EdgeList_insertBack( outerNode->entranceNodes, edgeData[i] ); */
+            EdgeList_insertNodeId( outerNode->edges, nodeData->vector[i] );
+            ++outerNode->entranceCount;
+        }
+}
+
+
+/* buildNodeFromData takes the integer array built by the above
+ * method, and creates a node from it. If that node has
+ * edge data, that is also built. The data is in an array,
+ * the size of which is also passed in.
+ */
+Node *buildNodeFromData( IntVector *nodeData )
+{
+    int i;
+    int edgeCount;
+
+    /* some basic error checking */
+    if ( nodeData == NULL || nodeData->size == 0 )
+        return( NULL );
+
+    Node *node = Node_new( nodeData->vector[0], -1 ); /* Calling method must set index. */
+    if ( !node )
+        return( NULL );
+
+    /* Currently, the second element in is the edge count */
+    edgeCount = nodeData->vector[1];
+    if ( edgeCount != nodeData->size-2 )
+    {
+        fprintf ( stderr, "Specified edge length does not match data size for node: %d\n",
+                  nodeData->vector[0] );
+    }
+
+    if ( edgeCount > 0 )
+    {
+        node->edges = EdgeList_new();
+        if ( node->edges )
+            for ( i = 2; i < nodeData->size; ++i )
+            {
+                EdgeList_insertNodeId ( node->edges, nodeData->vector[i] );
+                ++node->edgeCount;
+            }
+    }
+
+    return( node );
+}
+
+
+/* resolveNodeEdges is the second pass through the graph data
+ * structures. The first pass defines the nodes, and puts the edge
+ * ids in place. The second pass finds the nodes corresponding to
+ * the edge id, and sets the edge pointer to that node. Edges for
+ * outer nodes will only reference other outer nodes. Interior
+ * nodes may have edges to outer nodes or other interior nodes of
+ * their containing node. If an edge references an undefined node
+ * or if an edge goes into the interior of another outer node,
+ * the user will be notified.
+ *
+ * Note: The section that resolves entrance edges has been commented
+ * out because entrance edges are now processed as part of the edge
+ * list.
+ */
+void resolveNodeEdges( Graph *graph, Node* sourceNode, bool outerNode )
+{
+    EdgeList *edges;
+    Node *node;
+    bool okSoFar;
+
+    for ( edges = sourceNode->edges; edges != NULL; edges = edges->nextEdge )
+    {
+        if ( outerNode )
+        {
+            /* We only check for edges to other outer nodes*/
+            node = Graph_findNode( graph, edges->targetNodeId, true ); /* true-> check outer and interior nodes */
+            if ( node )
+            {
+                okSoFar = true;
+                /* Since entrance edges are now part of our edge list, we have to make sure
+                 * the link here is appropriate.
+                 */
+                if ( node->type == entranceNode || node->type == interiorNode )
+                {
+                    if ( node->container != sourceNode )
+                    {
+                        fprintf( stderr,
+                                 "resolveNodeEdges: Outer node %d edge to non-contained node: %d\n",
+                                 sourceNode->id, edges->targetNodeId );
+                        fprintf(stderr, "\t%d is type: %s (%d)\n", node->id, node->type == interiorNode ? "interior" : "entrance", (int)node->type);
+                        okSoFar = false;
+                    }
+                }
+                if ( okSoFar )
+                    edges->targetNode = node;
+            }
+            else
+                fprintf( stderr,
+                        "resolveNodeEdges: Outer node %d has edge reference to undefined node: %d\n",
+                        sourceNode->id, edges->targetNodeId );
+        }
+        else
+        {
+            /* Interior node - the edge can be to an outer node... */
+            node = Graph_findNode( graph, edges->targetNodeId, false ); /* false-> only check outer nodes */
+            if ( node )
+                edges->targetNode = node;
+            else
+            {
+                /* ... or nodes interior to the container of this node */
+                node = Graph_findContainedNode( sourceNode->container, edges->targetNodeId );
+                if ( node )
+                    edges->targetNode = node;
+                else
+                {
+                    /* we have an undefined node */
+                    fprintf( stderr,
+                            "resolveNodeEdges: Interior node %d has edge reference to undefined node: %d\n",
+                            sourceNode->id, edges->targetNodeId );
+                }
+            }
+        }
+    }
+
+}
+
+
+/* pruneLine takes the \r\n off the end of the label. This is an artifact of
+ * the windows file system, not something that was intended to be a part
+ * of the actual label string.
+ */
+static void pruneLine( char *label )
+{
+    int i = 0;
+
+    for ( ; label[i] != '\0'; ++i )
+    {
+        if ( label[i] == '\r' )
+        {
+            label[i] = '\0';
+            return;
+        }
+        if ( label[i] == '\n' )
+        {
+            label[i] = '\0';
+            return;
+        }
+    }
+}
+
+/* parseFile goes through the specified file to build the graph. It
+ * returns a pointer to the graph instance created by the data. Otherwise
+ * it returns NULL if the file is not parsable.
+ */
+
+Graph *parseFile( char *fileName )
+{
+    FILE *inFile;
+    IntVector *fileData = NULL;
+    CharVector *fileString = NULL;
+    Node *newNode = NULL;
+    Node *outerNode = NULL;
+    Node *findNode = NULL;
+    int temp, count;
+    NodeList *outerNodeList = NULL;
+    NodeList *innerNodeList = NULL;
+    Graph *newGraph = NULL;
+    int funcCount = 50; /* used as a default initial size for the system call table */
+    int blockCount =  0;
+    bool systemCallSection = false;
+    int i;
+
+    /* A little error checking */
+    if ( !fileName )
+        return( NULL );
+
+#ifdef PRINT_FILE
+    printf ( "Parsing file %s...\n", fileName );
+#endif
+
+    inFile = fopen( fileName, "r" );
+    if ( !inFile )
+    {
+        printf( "Could not open data file: %s (parsing.c:parseFile)\n", fileName );
+        return( NULL );
+    }
+    /* else
+        printf( "Opened %s\n\n", fileName ); */
+
+    newGraph = Graph_new();
+    if ( !newGraph )
+        return( NULL );
+
+    newGraph->fileName = strdup( fileName );
+    fileString = CharVector_new( 1024 ); /* allocate our data parsing storage - 1024 is a semi-arbitrary power of 2 */
+
+    i = 0;
+
+    /* The first two lines define the number of Functions and basic blocks. */
+    CharVector_getLineFromFile( fileString, inFile );
+    if ( !feof( inFile ) && ( strncmp ( "Functions:", fileString->string, 10 ) == 0 ) )
+    {
+        funcCount = atoi ( fileString->string+10 );
+        printf ( "\t%d functions specified\n", funcCount );
+        YAMLWriteInt("Functions", funcCount);
+    }
+    else
+    {
+        fprintf ( stderr, "Malformed file, Function count not specified in first line\n" );
+        return( NULL );
+    }
+
+    CharVector_getLineFromFile( fileString, inFile );
+    if ( !feof( inFile ) && ( strncmp ( "Basic blocks:", fileString->string, 13 ) == 0 ) )
+    {
+        blockCount = atoi ( fileString->string+13 );
+        printf ( "\t%d basic blocks specified\n", blockCount );
+        YAMLWriteInt("Basic Blocks", blockCount);
+    }
+    else
+    {
+        fprintf ( stderr, "Malformed file, Function count not specified in first line\n" );
+        return( NULL );
+    }
+
+    // printf ("Done with header\n");
+
+    fileData = IntVector_new( 8 ); /* allocate our data parsing storage - 8 is a semi-arbitrary power of 2 */
+
+    /*
+     * The first section defines the outer nodes. Scan through it to identify the
+     * nodes and to do the first pass of edge definition.
+     */
+    while ( !feof( inFile ) ) /* clumsy use of feof */
+    {
+        CharVector_getLineFromFile( fileString, inFile );
+
+        if ( feof( inFile ) ) /* that read line was the last line */
+            break;
+
+        if ( strncmp( "----------", fileString->string, 10 ) == 0 ) /* we have a section break */
+            break;
+
+        count = IntVector_createFromString ( fileData, fileString->string );
+
+        if ( count > 0 )
+        {
+            // printf("processing node %d\n", fileData->vector[0] );
+            newNode = buildNodeFromData( fileData );
+            if ( newNode )
+            {
+                Graph_addOuterNode( newGraph, newNode );
+                newNode->nodeCount = newGraph->totalNodes;
+                newGraph->totalNodes += 1;
+            }
+        }
+        IntVector_clear( fileData );
+    }
+
+    //printf ("Done with outer nodes\n");
+
+    /* Parse the subsequent sections to get the inner nodes */
+    while ( !feof( inFile ) )
+    {
+        /* The first line will identify the outer node for which the inner nodes are defined. */
+        CharVector_getLineFromFile( fileString, inFile );
+
+        if ( feof( inFile ) ) /* that fgets was the last line */
+            break;
+
+        systemCallSection = strncmp( "SYSTEM CALLS", fileString->string, 12) == 0;
+        if ( systemCallSection )
+            break;
+
+        if ( isdigit( (int)fileString->string[0] ) )
+            temp = atoi( fileString->string ); /* Note: No format error check here... */
+        else
+            temp = -1; /* Man, I hope -1 is never a node id value... */
+        outerNode = Graph_findNode( newGraph, temp, false ); /* false -> only check outer nodes */
+
+        if ( outerNode == NULL )
+        {
+            fprintf (stderr, "Error in parseFile: Node %d undefined as an outer node\n", temp );
+            break; /* No error recovery  - but continue with the program */
+        }
+
+        /* Now, subsequent lines (up to the section break) identify interior nodes; */
+        while  ( !feof( inFile ) )
+        {
+            CharVector_getLineFromFile( fileString, inFile );
+
+            if ( strncmp( "----------", fileString->string, 10 ) == 0 ) /* we have a section break */
+                break;
+
+            count = IntVector_createFromString( fileData, fileString->string );
+            if ( count > 0 )
+            {
+                /*
+                 * special case: If the node specified is the outerNode, the edge nodes specified
+                 * here are the entrance nodes
+                 */
+                if ( fileData->vector[0] == outerNode->id )
+                    buildEntranceList( outerNode, fileData );
+                else
+                {
+                    newNode = buildNodeFromData( fileData );
+                    if ( newNode )
+                    {
+                        Node_addInteriorNode( outerNode, newNode );
+                        newNode->nodeCount = newGraph->totalNodes;
+                        newGraph->totalNodes += 1;
+                    }
+                }
+            }
+            IntVector_clear( fileData );
+        }
+    }
+
+    //printf ( "Done with interior nodes. On to System Calls\n" );
+
+    /* All the node mappings have been done, now we build a map of system calls to the
+     * node keys.
+     */
+    newGraph->systemCallMap = SystemCallMap_new( funcCount );
+    if ( newGraph->systemCallMap == NULL )
+    {
+        IntVector_delete( fileData );
+        return( NULL ); /* if we can't build the system call map, we're done. */
+    }
+
+    if ( systemCallSection )
+    {
+        while ( !feof( inFile ) )
+        {
+            CharVector_getLineFromFile( fileString, inFile );
+            
+            if ( feof( inFile ) ) /* that fgets was the last line */
+                break;
+
+            if ( isdigit( (int)fileString->string[0] ) )
+                temp = atoi ( fileString->string ); /* get the key */
+            else
+                temp = -1;
+            if ( temp >= 0 ) /* valid key */
+            {
+                /* get the system call name. First, get past the ' ' */
+                for ( i = 0; fileString->string[i] != '\0' && fileString->string[i] != ' '; ++i ) {}
+                if ( fileString->string[i] == ' ' )
+                {
+                    ++i;
+                    findNode = Graph_findNode( newGraph, temp, true );
+                    pruneLine( fileString->string+i );
+                    SystemCallMap_insert( newGraph->systemCallMap, fileString->string+i, findNode );
+                }
+            }
+        }
+    } /* ....aaaand we're done parsing the input file. */
+
+    CharVector_delete(fileString);
+
+    //printf ( "Done parsing, resolve edges\n" );
+    /* Now that we have all the nodes, resolve all edge definitions */
+    for ( outerNodeList = newGraph->outerNodes;
+          outerNodeList != NULL;
+          outerNodeList = outerNodeList->nextNode )
+    {
+        resolveNodeEdges( newGraph, outerNodeList->node, true ); /* true -> outer node */
+        for ( innerNodeList = outerNodeList->node->interiorNodes;
+              innerNodeList != NULL;
+              innerNodeList = innerNodeList->nextNode )
+        {
+            resolveNodeEdges( newGraph, innerNodeList->node, false ); /* false -> interior node */
+        }
+    }
+
+
+    /* How many nodes did we count (outer + interior)?
+    printf ( "\tTotal nodes parsed: %d\n", newGraph->totalNodes ); */
+
+    /* Debug --* /
+    graphPrettyPrint( newGraph );
+    systemCallMapPrettyPrint( newGraph->systemCallMap );
+    / *-- End Debug */
+    
+    printf( "\t%d total System Call Map elements\n", newGraph->systemCallMap->contentSize );
+    YAMLWriteInt( "System Calls", newGraph->systemCallMap->contentSize );
+
+    /* Build the search diagram */
+    newGraph->searchDiagram = SearchDiagram_build( newGraph->outerNodes, newGraph->totalNodes );
+
+    printf ( "\t...parsing complete.\n" );
+    return( newGraph );
+}
+
+
+
+
+/* parseSignature takes a space delimited string and turns it
+ * into a "signature" - a packed array of c-string pointers with
+ * a NULL pointer to signify completion.
+ */
+char **parseSignature( char *data )
+{
+    int i = 0;
+    int labelCount = 0; // Used to be 1. The algorithm depends on a terminating space, so it counts based on the END of the label.
+    int copiedLabels = 0;
+    char **labels = NULL;
+    char *debug = NULL;
+
+    /* A little error checking */
+    if ( !data )
+        return NULL;
+
+    /* First, scream through the array counting labels */
+    for( i = 0; data[i] != '\0'; ++i )
+    {
+        if ( data[i] == ' ' )
+        {
+            ++labelCount;
+            data[i] = '\0';
+        }
+    }
+
+    /* Now, allocate the array and make copies */
+    labels = (char **)malloc( (labelCount+1) * sizeof(char*) );
+    i = 0;
+    if ( labels )
+    {
+        for ( copiedLabels = 0; copiedLabels < labelCount; ++copiedLabels )
+        {
+            debug = &data[i];
+            labels[copiedLabels] = strdup( &data[i] );
+            while ( data[i] != '\0' )
+            {
+                /* advance to the end of this label */
+                ++i;
+            }
+            ++i; /* advance beyond the \0 to the start of the next label */
+        }
+        labels[labelCount] = NULL; /* terminate the array */
+    }
+
+    /* Debug print out * /
+    printf ( "\nSignature: ");
+    for ( i = 0; labels[i] != NULL; ++i )
+    {
+        printf ( "%s ", labels[i] );
+    }
+    /* end Debug */
+
+    return labels;
+}
+
+
+
+
+
+/* parseConfigFile reads the data file names and desired search
+ * signatures from the config file. It returns a packed array
+ * of Graph pointers populated corresponding to the data files.
+ * Also, it returns a packed array of pointers to signatures.
+ * (Signatures are themselves packed arrays to C-Strings.) These
+ * packed arrays are terminated with a NULL pointer. They
+ * are returned in the "graphs" and "signatures" parameters
+ * which should be references to the desired pointers. See main.c.
+ */
+bool parseConfigFile( char *configFileName, Configuration *config )
+{
+    char data[1000];
+    FILE *configFile = NULL;
+    int fileNum = -1;
+    int sigNum = -1;
+    int i = 0;
+
+    configFile = fopen( configFileName, "r" );
+    if ( !configFile )
+    {
+        printf( "Could not open %s\n", configFileName );
+        return( NULL );
+    }
+    else
+        printf( "Opened %s\n\n", configFileName );
+
+    fgets ( data, 1000, configFile );
+    if ( feof( configFile ) || ( strncmp ( "Pathfinder Configuration", data, 24 ) != 0 ) )
+    {
+        printf( "Error in config file: doesn't start with \"Pathfinder Configuration\"\n" );
+        return false;
+    }
+
+    fgets ( data, 1000, configFile );
+    if ( feof( configFile ) || ( strncmp ( "files", data, 5 ) != 0 ) )
+    {
+        printf( "Error in config file: second line is not file count\n" );
+        return false;
+    }
+    fileNum = atoi( &data[6] );
+    if ( fileNum == 0 )
+    {
+        printf( "No files to parse, exiting.\n" );
+        return false;
+    }
+
+    fgets ( data, 1000, configFile );
+    if ( feof( configFile ) || ( strncmp ( "signatures", data, 10 ) != 0 ) )
+    {
+        printf( "Error in config file: third line is not signature count\n" );
+        return false;
+    }
+    sigNum = atoi( &data[11] );
+    if ( sigNum == 0 )
+    {
+        printf( "No signatures to search, exiting.\n" );
+        return false;
+    }
+
+    fgets ( data, 1000, configFile );
+    if ( feof( configFile ) || ( strncmp ( "search type", data, 11 ) != 0 ) )
+    {
+        printf( "Error in config file: third line is not signature count\n" );
+        return false;
+    }
+    if ( strncmp( &data[12], "tree", 4 ) == 0 )
+        config->searchOptions->searchType = treeSearch;
+    else
+        config->searchOptions->searchType = diagramSearch;
+
+    config->graphs = (Graph **)malloc( (fileNum+1) * sizeof( Graph* ) );
+    if ( !config->graphs )
+    {
+        printf ( "Could not allocate graph storage. Exiting\n" );
+        return false;
+    }
+
+    for ( i = 0; i < fileNum; ++i )
+    {
+        fgets ( data, 1000, configFile );
+        if ( feof( configFile ) || ( strncmp ( "file ", data, 5 ) != 0 ) ) /* note the ' ' */
+        {
+            printf( "Error in config file: mismatch of file count\n" );
+            return false;
+        }
+
+        /* strip the \n from the file name. */
+        pruneLine( &data[5] );
+        config->graphs[i] = parseFile( &data[5] );
+        if ( !config->graphs[i] )
+        {
+            /* the file did not parse */
+            printf( "Error parsing %s", &data[5] );
+            free( config->graphs );
+            return false;
+        }
+    }
+    config->graphs[fileNum] = NULL;
+
+    config->signatures = (Signature *)malloc( (sigNum+1) * sizeof( Signature ) );
+    if ( !config->signatures )
+    {
+        printf ( "Could not allocate signature storage. Exiting\n" );
+        return false;
+    }
+
+    for ( i = 0; i < sigNum; ++i )
+    {
+        fgets ( data, 1000, configFile );
+        if ( feof( configFile ) || ( strncmp ( "signature ", data, 10 ) != 0 ) ) /* note the ' ' */
+        {
+            printf( "Error in config file: mismatch of signature count\n" );
+            return false;
+        }
+
+        /* strip the \n from the file name. */
+        pruneLine( &data[10] );
+        config->signatures[i] = parseSignature( &data[10] );
+        if ( !config->signatures[i] )
+        {
+            /* the file did not parse */
+            printf( "Error parsing %s", &data[10] );
+            free( config->graphs ); /* Insufficient! Should call a destructor on each */
+            free( config->signatures );
+            return false;
+        }
+    }
+    config->signatures[sigNum] = NULL;
+
+    return true;
+}
+
+
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/searchAlgorithms.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+ 
+ /*
+ * searchAlgorithms.h
+ *
+ *  Created on: Jun 18, 2013
+ *      Author: Brian "Rig" Rigdon
+ */
+
+#ifndef SEARCHALGORITHMS_H_
+#define SEARCHALGORITHMS_H_
+
+
+#include "vectorUtils.h"
+#include "graph.h"
+#include "configuration.h"
+
+
+/* findNextLabel is a recursive method that determines if a path exists between a
+ * specific node and the label that is at the start of the label array argument. The
+ * label array is an array of char pointers that is terminated with a NULL pointer. The
+ * first pointer is the "current" label.
+ *
+ * The node's edge nodes are checked against the current label. If none of them match, then
+ * this method recurses with each edge node and the current label.
+ *
+ * If an edge matches, then we are beginning a search for the next "leg" of the labels.
+ * We recurse with that specific edge and the "next" label. That is the [1] element of
+ * the label array. If that element is NULL, the matching edge signifies the end of our
+ * search! VICTORY!
+ *
+ * If we reach the last edge with out a match (directly or recursively) we return a false
+ * list.
+ */
+
+bool findNextLabel( Node *node, char *labels[], NodePtrVec *result, Bitfield *visited ); /* NodePtrVec *visited ); */
+
+/* findAndRecordAllPaths is almost exactly like findNextLabel. It differs only in that it
+ * 1) doesn't stop with the first discovery of the specified path and 2) records the discovered
+ * path. To do this, it doesn't create a new result vector for
+ */
+
+void findAndRecordAllPaths( Node *node, Signature labels, int *labelIdxs,
+        NodePtrVec *result, Bitfield *visited, NodeVecVec *storage,
+        SearchOptions *options );
+
+/*
+ *  findLabelPath takes an array of labels, determines if there are nodes associated
+ * with the labels (each label search will return a NodePtrVec*), and determine if
+ * paths exist passing through the set of labels.
+ */
+bool findLabelPath( Graph *graph, Signature labels, NodePtrVec *result, SearchType searchType );
+
+/*
+ *  findAllPossibleLegs does an exhaustive search through each possible label
+ * pairing to determine which legs are possible. This is a brute-force nxn
+ * approach that builds a signature holding only the second label and then
+ * searches for that signature from the nodes representing the first label.
+ * For the time being, it simply prints out the legs that are  possible in
+ * this graph.
+ */
+int findAllPossibleLegs( Graph *graph, SearchType searchType );
+
+/*
+ * findAndLogAllPossibleLegs is a duplicate of the above method, but it
+ * stores the results that are found
+ */
+
+int findAndLogAllPossibleLegs( Graph *graph, SearchOptions *options );
+
+/* Once the configuration file is parsed, a config structure is created that
+ * specifies the graphs and the signatures to be searched against. This method
+ * does multiple signature searches against multiple files 
+ */
+ 
+void doMultiSearchesQT(Configuration *config);
+
+#endif /* SEARCHALGORITHMS_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/searchAlgorithms.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+ /*
+ * searchAlgorithms.c
+ *
+ *  Created on: Jun 18, 2013
+ *      Author: jbrigdo
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <math.h>
+
+#ifdef USE_OMP
+#include <omp.h>
+#endif
+
+#include "searchAlgorithms.h"
+#include "vectorUtils.h"
+#include "utils.h"
+#include "graphGen.h"
+#include "statistics.h"
+
+
+extern double currentTime();
+
+static Stats *globalStats = NULL;
+
+
+
+void doMultiSearches(Configuration *config)
+{
+    NodePtrVec *result;
+    bool success;
+    Graph *graph;
+    Signature signature;
+    int i;
+    int j;
+    char *debug;
+    double tick, tock;
+    int hours;
+    int min;
+    double sec;
+
+    tick = currentTime();
+    result = NodePtrVec_new(64); /* 64 is an arbitrary size */
+
+    for ( i = 0; config->signatures[i] != NULL; ++i )
+    {
+        signature = config->signatures[i];
+        /* Debug --* /
+        printf ("\n\nSignature (");
+        for ( k = 0; signature[k] != NULL; ++k )
+        {
+            debug = signature[k];
+            printf("%s", signature[k]);
+            if ( signature[k+1] != NULL )
+                printf(" ");
+            else
+                printf("):\n");
+        }
+        / *-- End Debug */
+        // printf("Signature %d:\n", i);
+        for ( j = 0; config->graphs[j] != NULL; ++j )
+        {
+            graph = config->graphs[j];
+            result->contentSize = 0; /* clear last search's result */
+            // printf("\t checking file %s... ", graph->fileName);
+            fflush(stdout);
+            success = findLabelPath(graph, signature, result, config->searchOptions->searchType);
+            if ( success )
+                {}// printf("Found!\n");
+            else
+                {}// printf("Not found. Bummer.\n");
+        }
+    }
+
+    tock = currentTime();
+    sec = tock-tick;
+    hours = (int)sec/3600;
+    sec = fmod( sec, 3600.0 );
+    min = (int)sec/60;
+    sec = fmod(sec, 60.0);
+    printf ("\n\nOverall Search Time: %02d:02%d:%05.2f\n", hours, min, sec);
+
+}
+
+/* findNextLabel is a recursive method that determines if a path exists between a
+ * specific node and the label that is at the start of the label array argument. The
+ * label array is an array of char pointers that is terminated with a NULL pointer. The
+ * first pointer is the "current" label.
+ *
+ * The node's edge nodes are checked against the current label. If none of them match, then
+ * this method recurses with each edge node and the current label.
+ *
+ * If an edge matches, then we are beginning a search for the next "leg" of the labels.
+ * We recurse with that specific edge and the "next" label. That is the [1] element of
+ * the label array. This starts the search along the next leg - at this point we have
+ * to start a new "result" vector, because we check that vector for loops. It MAY be the
+ * case that the next path segment passes through nodes already traversed in a previous
+ * leg. A new "result" vector will solve that.
+ *
+ * If the next element in the labels list is NULL, the matching edge signifies the end of
+ * our search! VICTORY!
+ *
+ * If we reach the last edge with out a match (directly or recursively) we return a false
+ * list.
+ */
+
+bool findNextLabel( Node *node, Signature labels, NodePtrVec *result, Bitfield *visited ) /* NodePtrVec *visited ) */
+{
+    EdgeList *edge;
+    bool success = false;
+    NodePtrVec *nextLegResult = NULL;
+    /* NodePtrVec *nextLegVisited = NULL; */
+    Bitfield *nextLegVisited = NULL;
+
+
+    /* A little basic error checking */
+    if ( !node || !labels || !result|| !visited )
+    {
+        return( false );
+    }
+
+    /* If this node is already in the vector, we have found a loop. return false. */
+
+    if ( Bitfield_nodeVisited( visited, node ) )
+        return( false );
+
+    /* put this node on the result vector to show that we've been here */
+    NodePtrVec_push( result, node );
+
+    /* Check this node's edges to see if there's a match */
+    /* Note: We have a NodePtrVec holding the set of nodes with this label. It
+     *       may be more optimal to see if a given edge node is in that set
+     *       rather than doing a bunch of inefficient strcmp calls. Another approach
+     *       would be to have unique hash values for each label, and thereby be
+     *       able to compare those. However for the initial version of this code,
+     *       keeping things simple and straightforward, we're doing the string
+     *       compare.
+     */
+
+    for ( edge = node->edges; edge != NULL; edge = edge->nextEdge )
+    {
+
+        // string based:
+        if ( edge->targetNode->label && strcmp( edge->targetNode->label, labels[0] ) == 0 )
+        // index based: if ( edge->targetNode->labelIdx == labelIdxs[0] )
+        {
+            if ( labels[1] != NULL ) /* more steps in the signature */
+            {
+                nextLegResult = NodePtrVec_new( 50 ); /* arbitrary size, malloc success checked in recursion */
+                nextLegVisited = Bitfield_new(visited->bitsNeeded);
+
+                success = findNextLabel( edge->targetNode, &labels[1], nextLegResult, nextLegVisited );
+                /* NodePtrVec_delete( nextLegVisited ); */
+                Bitfield_delete( nextLegVisited );
+                if ( success )
+                {
+                    NodePtrVec_appendVectors( result, nextLegResult, true );
+                    NodePtrVec_delete( nextLegResult );
+                    return( true );
+                }
+
+            }
+            else /* We have exhausted the signature - ultimate victory! */
+            {
+                /* Register this edge node as being the final node */
+                NodePtrVec_push( result, edge->targetNode );
+                return( true );
+            }
+        }
+    }
+
+
+    /* IF we made it here, we need to continue through the tree, seeing if any of our
+     * edge nodes have a connection to a labeled node.
+     */
+    for ( edge = node->edges; edge != NULL; edge = edge->nextEdge )
+    {
+        success = findNextLabel( edge->targetNode, labels, result, visited );
+        if ( success )
+            return( true ); /* this edge has a path to the ultimate signature path */
+    }
+
+
+    /* and, if we make it here, we have failed. */
+    NodePtrVec_pop( result ); /* take current node off the result vector */
+    return false;
+}
+
+
+
+/* A method to custom-store our results */
+static void logStats(NodePtrVec *result)
+{
+    if ( !result ) return;
+    if ( !globalStats )
+        globalStats = Stats_new();
+    Stats_logPath(globalStats, result);
+}
+
+static void printStats()
+{
+    int i;
+
+    if ( globalStats )
+    {
+        Stats_calculate(globalStats);
+
+        printf ( "\nThis graph has %f average nodes between labels.\nStandard deviation: %f, total paths: %d\n\n",
+                globalStats->averageLength, globalStats->standardDeviation, globalStats->pathLengths->size );
+        printf ("\tShortest Path: %d, Longest Path: %d\n", globalStats->minLength, globalStats->maxLength);
+        for ( i = globalStats->minLength; i <= globalStats->maxLength; ++i )
+        {
+            if ( globalStats->histogram[i] != 0 )
+                printf ("\tlength %d appeared %d times\n", i, globalStats->histogram[i] );
+        }
+
+    }
+}
+
+
+/* A method to custom-store our results */
+
+/* At some point, we will want to use the FullPath argument and pass it along to
+ * buildGraphFromPaths. Until then, however, we're only going to build the most
+ * minimal graph possible.
+ */
+static void logResult(NodeVecVec *storage, NodePtrVec *result, SearchOptions *options)
+{
+    NodePtrVec *tips = NodePtrVec_new(2);
+    if ( !storage || !result || !tips ) return;
+
+    /* We log the stats here, because the storage method below may not hold
+     * the entire path.
+     */
+    if ( !options->multiThreaded && options->doStatistics ) /* statistics are not thread-safe yet */
+        logStats(result);
+
+    /* Ultimately we may want to log more than the ends... */
+    /* Future: if ( options->buildType == endNodesOnly ) { */
+    NodePtrVec_push(tips, result->vector[0]);
+    NodePtrVec_push(tips, result->vector[result->contentSize-1]);
+    if ( !NodeVecVec_insert(storage, tips) ) /* makes a copy of tips, so we need to... */
+    {
+        printf("CrashAndBURN!!!\n\n");
+        fflush(stdout);
+    }
+    NodePtrVec_delete(tips); /* ... free the mallocs! */
+}
+
+
+
+/* findAndRecordAllPaths is almost exactly like findNextLabel. It differs only in that it
+ * 1) doesn't stop with the first discovery of the specified path and 2) records the discovered
+ * path. To do this, it doesn't create a new result vector for
+ */
+
+void findAndRecordAllPaths( Node *node, Signature labels, int *labelIdxs,
+        NodePtrVec *result, Bitfield *visited, NodeVecVec *storage,
+        SearchOptions *options )
+{
+    EdgeList *edge;
+    /* NodePtrVec *nextLegVisited = NULL; */
+    Bitfield *nextLegVisited = NULL;
+
+
+    /* A little basic error checking */
+    if ( !node || !labels || !labelIdxs || !result|| !visited )
+    {
+        return;
+    }
+
+    /* If this node is already in the vector, we have found a loop. return false. */
+/*
+    if ( NodePtrVec_findReverse( visited, node ) )
+        return( false );
+    else
+        NodePtrVec_push( visited, node );
+*/
+    if ( Bitfield_nodeVisited( visited, node ) )
+        return;
+
+    /* put this node on the result vector to show that we've been here */
+    NodePtrVec_push( result, node );
+
+    /* Check this node's edges to see if there's a match */
+    /* Note: We have a NodePtrVec holding the set of nodes with this label. It
+     *       may be more optimal to see if a given edge node is in that set
+     *       rather than doing a bunch of inefficient strcmp calls. Another approach
+     *       would be to have unique hash values for each label, and thereby be
+     *       able to compare those. However for the initial version of this code,
+     *       keeping things simple and straightforward, we're doing the string
+     *       compare.
+     */
+
+    for ( edge = node->edges; edge != NULL; edge = edge->nextEdge )
+    {
+
+        // string based:
+        if ( edge->targetNode->label && strcmp( edge->targetNode->label, labels[0] ) == 0 )
+        // index based: if ( edge->targetNode->labelIdx == labelIdxs[0] )
+        {
+            // strcmp based:
+            if ( labels[1] != NULL ) /* more steps in the signature */
+            // index based: if ( labelIdxs[1] != -1 ) /* more steps in the signature */
+            {
+                nextLegVisited = Bitfield_new(visited->bitsNeeded);
+                findAndRecordAllPaths(edge->targetNode, &labels[1], &labelIdxs[1], result,
+                        nextLegVisited, storage, options );
+                Bitfield_delete(nextLegVisited);
+            }
+            else /* We have exhausted the signature - ultimate victory! */
+            {
+                /* Register this edge node as being the final node */
+                // printf ("\tFound!\n");
+                NodePtrVec_push(result, edge->targetNode);
+                Bitfield_nodeVisited(visited, edge->targetNode);/* Mark it as visited */
+                logResult(storage, result, options); // <<<--- here's where I record it
+                NodePtrVec_pop(result);
+            }
+        }
+    }
+
+
+    /* IF we made it here, we need to continue through the tree, seeing if any of our
+     * edge nodes have a connection to a labeled node.
+     */
+    for ( edge = node->edges; edge != NULL; edge = edge->nextEdge )
+    {
+        findAndRecordAllPaths(edge->targetNode, labels, labelIdxs, result, visited, storage, options);
+    }
+
+    NodePtrVec_pop( result ); /* take current node off the result vector */
+    return;
+}
+
+
+
+/* findLabelPath takes an array of labels, determines if there are nodes associated
+ * with the labels (each label search will return a NodePtrVec*), and determine if
+ * paths exist passing through the set of labels. This returns the first FOUND
+ * path, not the optimal one. We could do that in a future iteration of the code
+ * by keeping track of all paths found, and going with the shortest.
+ *
+ * The labels passed in is an array of char pointers. The array is null terminated -
+ * i.e. the last valid entry in the array is followed by a pointer with NULL in it.
+ */
+bool findLabelPath( Graph *graph, Signature labels, NodePtrVec *result, SearchType searchType )
+{
+    NodePtrVec *startNodes = NULL; /* set of nodes with the first label - potential path start nodes */
+    int i;
+    bool found = false; /* stopping as soon as we can find a path to a final node */
+    /* NodePtrVec *visited = NodePtrVec_new( 50 ); /-* arbitrary size *-/ */
+    Bitfield *visited = Bitfield_new(graph->totalNodes);
+
+
+    /* some basic error checking */
+    if ( !graph || !labels || !labels[0] || !labels[1] || !result  || !visited )
+        return( false );
+
+    /* Un-comment to short-circuit searches for non-represented signatures. -->* /
+    if ( !SystemCallMap_signatureRepresented( graph->systemCallMap, labels ) )
+    {
+        //printf( "%s %s invalid signature labels for graph.\n", labels[0], labels[1] );
+        return( false );
+    }
+    / *<-- end of short-circuit region */
+
+    startNodes = SystemCallMap_findLabeledNodes( graph->systemCallMap, labels[0] );
+
+    if ( !startNodes )
+        return( false );
+
+    /* So, if we've made it this far, we have a valid start label.  Now, we need to
+     * iterate through the start nodes and see if they can get to the next label...
+     */
+
+    for ( i = 0; i < startNodes->contentSize && !found; ++i )
+    {
+        if ( searchType == diagramSearch )
+        {
+            SearchDiagram *element = SearchDiagram_findNode( graph->searchDiagram, startNodes->vector[i] );
+            if ( element )
+                found = SearchDiagram_findSignatureAlongEdges( element->node, element->edgeReferenceArray,
+                                                               &labels[1], result, visited );
+        }
+        else
+            found = findNextLabel( startNodes->vector[i], &labels[1], result, visited );
+        Bitfield_clear( visited );
+
+        if ( !found && result->contentSize != 0 ) /* If it's not found the result SHOULD be empty, however... */
+            result->contentSize = 0; /* effectively clear the result NodePtrVec */
+    }
+
+
+    /* NodePtrVec_delete( visited ); */
+    Bitfield_delete( visited );
+    return( found );
+}
+
+
+/* findAllPossibleLegs does an exhaustive search through each possible label
+ * pairing to determine which legs are possible. This is a brute-force nxn
+ * approach that builds a signature holding only the second label and then
+ * searches for that signature from the nodes representing the first label.
+ * For the time being, it simply prints out the legs that are  possible in
+ * this graph.
+ */
+int findAllPossibleLegs( Graph *graph, SearchType searchType )
+{
+    int i, j;
+    int found = 0;
+    int searches = 0;
+    double tick, tock;
+    int hours, min;
+    double sec;
+    char timeStr[50];
+
+    tick = currentTime();
+    fprintf ( stdout, "Immediately before parallel\n" );
+
+    //#pragma omp parallel private(i,j) shared(graph) reduction(+:found) reduction(+:searches)
+    //#pragma omp single
+    {
+        //#pragma omp parallel for private(i,j) default(none)
+        #ifdef USE_OMP
+        #pragma omp parallel for private(i,j) shared(graph) reduction(+:found) reduction(+:searches) 
+        #pragma omp collapse(2)
+        #endif
+        for ( i = 0; i < graph->systemCallMap->contentSize; ++i )
+        {
+            for ( j = 0; j < graph->systemCallMap->contentSize; ++j )
+            {
+                ++searches;
+                char *fullSignature[3] = { NULL, NULL, NULL };
+                int fullIntSignature[3] = { 0, 0, -1 };
+                fullSignature[0] = graph->systemCallMap->vector[i]->label;
+                fullSignature[1] = graph->systemCallMap->vector[j]->label;
+                fullIntSignature[0] = i;
+                fullIntSignature[1] = j;
+                // NodePtrVec *result = NodePtrVec_new(25);
+
+                /* findLabelPath does the findNextLabel in the above loops */
+                //#pragma omp task shared(graph, fullSignature, found)
+                {
+                    NodePtrVec *result = NodePtrVec_new( 25 );
+                    if ( findLabelPath( graph, fullSignature, result, searchType ) )
+                    {
+//                        printStack(result);
+                        // logStats(result);
+                        ++ found;
+                    }
+                    else
+                    {
+//                        printf ( "\n\tPath does not exist %s --/ /-> %s. %d steps.\n", fullSignature[0],
+//                                 fullSignature[1], result->contentSize );
+                    }
+                    if ( result )
+                    {
+                        NodePtrVec_delete( result );
+                    }
+                }
+            }
+            //#pragma omp taskwait
+        }
+    }
+
+
+    tock = currentTime();
+
+
+    sec = tock-tick;
+    hours = (int)sec/3600;
+    sec = fmod( sec, 3600.0 );
+    min = (int)sec/60;
+    sec = fmod( sec, 60.0 );
+    printf ( "\n\n%d found out of %d searches. Overall Time: %d:%d:%2.3f\n",
+             found, searches, hours, min, sec );
+    timeStr[0] = '\0'; /* just in case sprintf doesn't do what we want. */
+    sprintf ( timeStr, "%02d:%02d:%02.3f", hours, min, sec );
+    YAMLWriteInt("Signatures Found", found);
+    YAMLWriteString("Search Time", timeStr);
+    
+
+    //printStats();
+
+    return( found );
+}
+
+/*
+ * findAndLogAllPossibleLegs has the same search algorithm as findAllPossibleLegs. However, the requirement
+ * that all the legs be logged requires a more sophisticated means of parallelization in order to do a
+ * reduction of the solutions when all the threads are done.
+ */
+int findAndLogAllPossibleLegs(Graph *graph, SearchOptions *options)
+{
+    int i, j, k;
+    int found = 0;
+    int searches = 0;
+    double tick, tock;
+    int hours, min;
+    double sec;
+    int maxThreads = 1;
+    NodeVecVec **lastingResults;
+    Graph *optimizedGraph = NULL;
+    char timeStr[50];
+
+    /* A little bit of error checking */
+    if ( !graph )
+        return 0;
+
+    tick = currentTime();
+    fprintf(stdout, "Immediately before parallel\n" );
+
+    #ifdef USE_OMP
+    #pragma omp parallel private(i,j,k) shared(graph,maxThreads,lastingResults) reduction(+:found) reduction(+:searches)
+    #endif
+    {
+        #ifdef USE_OMP
+        int myThread = omp_get_thread_num();
+        #else
+        int myThread = 0;
+        #endif
+
+        NodeVecVec *myResults = NULL;
+
+        #ifdef USE_OMP
+        #pragma omp single
+        #endif
+        {
+            #ifdef USE_OMP
+            maxThreads = omp_get_num_threads();
+            #else
+            maxThreads = 1;
+            #endif
+
+            options->multiThreaded = maxThreads > 1;
+            /* debug * /printf( "%d total threads, this one is %d\n", maxThreads, myThread ); /* debug */
+            lastingResults = malloc((maxThreads+1) * sizeof(NodeVecVec*) );
+            lastingResults[maxThreads] = 0; /* Null terminated to avoid having to keep track of bitsNeeded */
+        }
+
+        #ifdef USE_OMP
+        #pragma omp critical
+        #endif
+        {
+            lastingResults[myThread] = NodeVecVec_new(64); /* Arbitrary - multiple of 8, eventually cache line aligned... */
+            myResults = lastingResults[myThread];
+        }
+
+        #ifdef USE_OMP
+        #pragma omp single
+        #endif
+        {
+            printf ("Immediately before nested for's\n");
+        }
+
+        #ifdef USE_OMP
+        #pragma omp for 
+        #pragma omp collapse(2)
+        #endif
+        for ( i = 0; i < graph->systemCallMap->contentSize; ++i )
+        {
+            for ( j = 0; j < graph->systemCallMap->contentSize; ++j )
+            {
+                ++searches;
+                for (k = 0; k < graph->systemCallMap->vector[i]->nodes->contentSize; ++k)
+                {
+                    char *fullSignature[3] = { NULL, NULL, NULL };
+                    int fullIntSignature[3] = { 0, 0, -1 };
+                    fullSignature[0] = graph->systemCallMap->vector[i]->label;
+                    fullSignature[1] = graph->systemCallMap->vector[j]->label;
+                    fullIntSignature[0] = i;
+                    fullIntSignature[1] = j;
+                    NodePtrVec *result = NodePtrVec_new(16);
+                    Bitfield *visited = Bitfield_new(graph->totalNodes);
+                    /* debug ---> * /
+                    printf( "Searching for %s(%d) ~~~> %s\n", fullSignature[0],
+                            graph->systemCallMap->vector[i]->nodes->vector[k]->id,
+                            fullSignature[1]);
+                    /* <-- debug */
+                    findAndRecordAllPaths( graph->systemCallMap->vector[i]->nodes->vector[k], &fullSignature[1],
+                            &fullIntSignature[1], result, visited, myResults, options );
+                    Bitfield_delete(visited);
+                    if ( result )
+                        NodePtrVec_delete( result );
+                } // end of for (k)... fork? heh.
+            } // end of for (j)
+        } // end of for (i)
+
+        found = myResults->contentSize;
+    }
+
+    tock = currentTime();
+    sec = tock-tick;
+    hours = (int)sec/3600;
+    sec = fmod( sec, 3600.0 );
+    min = (int)sec/60;
+    sec = fmod( sec, 60.0 );
+    printf ( "\n\n%d found for %d searches. Overall Time: %d:%d:%2.3f\n",
+            found, searches, hours, min, sec );
+    timeStr[0] = '\0'; /* just in case sprintf doesn't do what we want. */
+    sprintf ( timeStr, "%02d:%02d:%02.3f", hours, min, sec );
+    YAMLWriteInt("Signatures Found", found);
+    YAMLWriteString("Search Time", timeStr);
+
+    /* debug --> * /
+    printf ("max threads still:%d\n", maxThreads);
+    for ( i = 0; i < maxThreads; ++i )
+    {
+        printf ( "printing out thread %d result - %d long\n", i, lastingResults[i]->contentSize );
+        for ( j = 0; j < lastingResults[i]->contentSize; ++j )
+        {
+            printf("\t");
+            printStack( lastingResults[i]->vector[j] );
+            printf("\n");
+        }
+    }
+    /* <-- debug */
+
+    /* At some point, we will want to use the FullPath argument and pass it along to
+     * buildGraphFromPaths. Until then, however, we're only going to build the most
+     * minimal graph possible.
+     */
+    if ( options->writeOutputFile && options->outputFile )
+    {
+        optimizedGraph = buildGraphFromPaths(lastingResults, options->buildType);
+        exportGraph(optimizedGraph, options->outputFile);
+    }
+
+    if ( options->doStatistics && !options->multiThreaded )
+        printStats();
+
+    return( found );
+}

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/searchDiagram.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * searchDiagram.h
+ *
+ *  Created on: Feb 1, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#ifndef SEARCHDIAGRAM_H_
+#define SEARCHDIAGRAM_H_
+
+#include "node.h"
+
+typedef struct SearchDiagramStruct SearchDiagram;
+typedef struct EdgeReferencesStruct EdgeReferences;
+
+struct SearchDiagramStruct
+{
+    Node *node;  /* a reference to the node */
+    EdgeReferences *edgeReferenceArray; /* All the nodes reachable from here */
+};
+
+/* We are creating arrays of SearchDiagram - constructor/destructor would be superfluous */
+
+
+/* The EdgeSearchStruct holds a different representation of
+ * the tree through which we're searching. Our search diagram
+ * will create an array of these for each node in the graph.
+ * Searches will go through the array, looking to match the
+ * search criteria. If the search is unsuccessful, it will
+ * then search the edges of the node. In this array, the  first
+ * element is the SEARCH ELEMENT we're comparing against. In
+ * this iteration of the code, we're using the Node pointer
+ * as the search key. The second element is the search edges
+ * contained by that node. The search edges are referenced
+ * directly, no need to go back to the SearchDiagram instance
+ * to get to the edges.
+ */
+
+struct EdgeReferencesStruct
+{
+    Node *edgeTarget; /* The address of the node is how we're defining our search */
+    EdgeReferences *targetNodeEdges; /* pointer to the "to" node's edge references */
+};
+
+/* We are creating arrays of EdgeReferences - constructor/destructor would be superfluous */
+
+/* Scream through the diagram to get the element corresponding to this Node* */
+SearchDiagram *SearchDiagram_findNode ( SearchDiagram *diagram, Node *node );
+
+/* The meat of this process - the function that creates the search diagram.
+ * It allocates the memory for the array of search diagram elements and
+ * populates them with node data and edgeID arrays.
+ */
+SearchDiagram *SearchDiagram_build ( NodeList *nodeTree, int nodeCount );
+
+
+/* And, our search methods. The first calls the second, which is recursive */
+
+bool SearchDiagram_findSignatureAlongEdges ( Node *node, EdgeReferences *edges,
+                                             char *labels[], NodePtrVec *result, Bitfield *visited );
+
+
+
+#endif /* SEARCHDIAGRAM_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/searchDiagram.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+
+/*
+ * searchDiagram.c
+ *
+ *  Created on: Feb 1, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#include "searchDiagram.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+/* Scream through the diagram to get the element corresponding to this key. This
+ * simply iterates through the entire list, there is no optimization in the search
+ * algorithm.
+ */
+SearchDiagram *SearchDiagram_findNode ( SearchDiagram *diagram, Node *node )
+{
+    int idx;
+
+    /* Do some basic error checking */
+    if ( !diagram )
+        return( NULL );
+
+    for ( idx = 0; diagram[idx].node != NULL; ++idx )
+    {
+        if ( diagram[idx].node == node ) /* We found it! */
+            return( &diagram[idx] );
+    }
+
+    /* If we made it here, we couldn't find it. */
+    return( NULL );
+}
+
+
+
+/* The meat of this process - the function that creates the search diagram.
+ * It allocates the memory for the array of search diagram elements and
+ * populates them with node data and edgeID arrays. Outer nodes are inserted
+ * into the node array from the lowest addresses and inner nodes are inserted
+ * into the search diagram from the highest. The authors did this to (hopefully)
+ * give a little more efficiency to the searching of the diagram.
+ */
+SearchDiagram *SearchDiagram_build( NodeList *nodeTree, int nodeCount )
+{
+    SearchDiagram *diagram = NULL;
+    NodeList *outerNodes = NULL;
+    Node *node = NULL;
+    NodeList *innerNodes = NULL;
+    /* Originally, we speculated that searches would stream through the outer
+     * nodes more than through the interior nodes. (We were wrong.) So we had
+     * this mechanism in place to put the outer nodes at the beginning of the
+     * diagram and the interior nodes at the end. Because we were wrong, this
+     * increases the likelihood of cache misses rather than decreasing it. Ergo
+     * we have replaced the outerIdx and the innerIdx calls.
+     *
+     * So... it turns out that putting the inner nodes near their containing
+     * node actually slows things down - but it's minor (2% - 3 minutes in a
+     * 120 minute run.)
+    int index = 0;
+     */
+    int outerIdx = 0;           /* index from the bottom up for outer nodes */
+    int innerIdx = nodeCount-1; /* and from the top down for interior nodes */
+
+    int edgeCount;
+    EdgeList *edges;
+    SearchDiagram *element; /* for searching in our diagram */
+
+    /* Do some basic error checking */
+    if ( !nodeTree || nodeCount == 0 )
+        return NULL;
+
+    /* Allocate an array of SearchDiagram Elements (+1 for a terminus element) */
+    diagram = malloc ( (nodeCount+1) * sizeof(SearchDiagram) );
+    if ( !diagram ) /* malloc failed */
+        return( NULL );
+
+    diagram[nodeCount].node = NULL;
+    diagram[nodeCount].edgeReferenceArray = NULL;
+
+    /* Scream through the Nodes and fill in the Search Array allocate space for edges */
+    for ( outerNodes = nodeTree; outerNodes != NULL; outerNodes = outerNodes->nextNode )
+    {
+        node = outerNodes->node;
+        /* This diagram entry needs a key */
+        diagram[outerIdx].node = node;
+        /* How many edges do we need? */
+        edgeCount = node->edgeCount + node->entranceCount;
+        if ( edgeCount > 0 ) /* allocate space for edgeIdArray (+1 for a terminus element) */
+        {
+            diagram[outerIdx].edgeReferenceArray = malloc ( (edgeCount+1) * sizeof(EdgeReferences) );
+            diagram[outerIdx].edgeReferenceArray[edgeCount].edgeTarget = NULL;
+            diagram[outerIdx].edgeReferenceArray[edgeCount].targetNodeEdges = NULL;
+        }
+        else
+            diagram[outerIdx].edgeReferenceArray = NULL;
+
+        /* What do we do if that malloc fails? */
+
+        /* increment the outer index: */
+        ++outerIdx;
+
+        /* Now do the same for this node's interior graph (if present) */
+        for ( innerNodes = node->interiorNodes; innerNodes != NULL; innerNodes = innerNodes->nextNode )
+        {
+            node = innerNodes->node;
+            diagram[innerIdx].node = node;
+            edgeCount = node->edgeCount + node->entranceCount;
+            if ( node->edgeCount > 0 ) /* allocate space for edgeIdArray (+1 for a terminus element) */
+            {
+                diagram[innerIdx].edgeReferenceArray = malloc ( (edgeCount+1) * sizeof(EdgeReferences) );
+                diagram[innerIdx].edgeReferenceArray[edgeCount].edgeTarget = NULL;
+                diagram[innerIdx].edgeReferenceArray[edgeCount].targetNodeEdges = NULL;
+            }
+            else
+                diagram[innerIdx].edgeReferenceArray = NULL;
+
+            /* Again, what do we do if that malloc fails? */
+
+            /* decrement the interior index: */
+            --innerIdx;
+        }
+
+    }
+
+
+    /* Check to make sure our counters line up. If they don't, we have a corrupt
+     * graph. That is, there is a mismatch between node definitions and edge lists.
+     * The innerIdx should reference the previous outerIdx location.
+     */
+    if ( outerIdx != innerIdx +1 )
+    {
+        /* Houston, we have a problem */
+        printf ( "Bummer. outerIdx: %d, innerIdx: %d, node count: %d\n", outerIdx, innerIdx, nodeCount );
+    }
+
+
+    /* For each node, populate its edge list - edges and entrance nodes (if there) */
+    outerIdx = 0;
+    innerIdx = nodeCount-1;
+    for ( outerNodes = nodeTree; outerNodes != NULL; outerNodes = outerNodes->nextNode )
+    {
+        /* iterate through this node's edges to populate the EdgeIdArray */
+        node = outerNodes->node;
+        for ( edges = node->edges, edgeCount = 0;
+              edges != NULL;
+              edges = edges->nextEdge, ++edgeCount )
+        {
+            element = SearchDiagram_findNode( diagram, edges->targetNode );
+            diagram[outerIdx].edgeReferenceArray[edgeCount].edgeTarget = edges->targetNode;
+            diagram[outerIdx].edgeReferenceArray[edgeCount].targetNodeEdges = element->edgeReferenceArray;
+        }
+        ++outerIdx;
+
+        /* And then scream through the interior nodes to take care of their edges */
+        for ( innerNodes = node->interiorNodes; innerNodes != NULL; innerNodes = innerNodes->nextNode )
+        {
+            node = innerNodes->node;
+            for ( edges = node->edges, edgeCount = 0;
+                  edges != NULL;
+                  edges = edges->nextEdge, ++edgeCount )
+            {
+                element = SearchDiagram_findNode( diagram, edges->targetNode );
+                diagram[innerIdx].edgeReferenceArray[edgeCount].edgeTarget = edges->targetNode;
+                diagram[innerIdx].edgeReferenceArray[edgeCount].targetNodeEdges = element->edgeReferenceArray;
+            }
+            --innerIdx;
+        }
+    }
+
+    return diagram;
+}
+
+
+
+bool SearchDiagram_findSignatureAlongEdges ( Node *node, EdgeReferences *edges,
+                                             char *labels[], NodePtrVec *result, Bitfield *visited )
+{
+    bool success = false;
+    NodePtrVec *nextLegResult = NULL;
+    Bitfield *nextLegVisited = NULL;
+    int i;
+
+    /* A little basic error checking */
+    if ( !node || !edges || !labels || !result|| !visited )
+    {
+        return( false );
+    }
+
+    /* If this node has already been visited, we have found a loop. return false. */
+
+/*
+    if ( NodePtrVec_findReverse( visited, node ) )
+        return( false );
+    else
+        NodePtrVec_push( visited, node );
+*/
+    if ( Bitfield_nodeVisited( visited, node ) )
+        return( false );
+
+    NodePtrVec_push( result, node );
+
+    /* Go through the edges once to see if we've found a label match */
+    for ( i = 0; edges[i].edgeTarget != NULL; ++i )
+    {
+        if ( edges[i].edgeTarget->label )
+        {
+            //strcmp based:
+            if ( strcmp( edges[i].edgeTarget->label, labels[0] ) == 0 ) /* match! */
+            // index based: if ( edges[i].edgeTarget->labelIdx == labelIdxs[0] )
+            {
+                if ( labels[1] == NULL ) /* end of the signature, we're DONE */
+                {
+                    NodePtrVec_push( result, edges[i].edgeTarget );
+                    return( true );
+                }
+                else /* RECURSE TO SEE IF THE REST OF THE SIGNATURE CAN BE FOUND!!! */
+                {
+                    nextLegResult = NodePtrVec_new( 50 ); /* arbitrary size, malloc success checked in recursion */
+                    nextLegVisited = Bitfield_new(visited->bitsNeeded);
+
+                    success = SearchDiagram_findSignatureAlongEdges ( edges[i].edgeTarget,
+                                                                      edges[i].targetNodeEdges,
+                                                                      &labels[1], nextLegResult, nextLegVisited );
+                    Bitfield_delete( nextLegVisited );
+                    if ( success )
+                    {
+                        NodePtrVec_appendVectors( result, nextLegResult, true );
+                        NodePtrVec_delete( nextLegResult );
+                        return( true );
+                    }
+                }
+            }
+        }
+    }
+
+    /* IF we made it here, we need to continue through the tree, seeing if any of our
+     * edge nodes have a connection to a labeled node.
+     */
+    for ( i = 0; edges[i].edgeTarget != NULL; ++i )
+    {
+        success = SearchDiagram_findSignatureAlongEdges( edges[i].edgeTarget,
+                                                         edges[i].targetNodeEdges,
+                                                         labels, result, visited );
+        if ( success )
+            return( true ); /* this edge has a path to the ultimate signature path */
+    }
+
+
+    /* and, if we make it here, we have failed. */
+    NodePtrVec_pop( result ); /* take current node off the result stack */
+    return false;
+}

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/statistics.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+
+/*
+ * statistics.h
+ *
+ *  Created on: Sept 24, 2013
+ *      Author: Brian "Rig" Rigdon
+ */
+
+#ifndef STATISTICS_H
+#define STATISTICS_H
+
+#include "vectorUtils.h"
+
+typedef struct HistogramElementStruct HistogramElement;
+struct HistogramElementStruct
+{
+    int length;
+    int count;
+    struct HistogramElementStruct *next;
+};
+
+HistogramElement *HistogramElement_new(int length);
+
+typedef struct StatsStruct Stats;
+struct StatsStruct
+{
+    IntVector *pathLengths;
+    int minLength;
+    int maxLength;
+    double averageLength; // does it make sense to say 2.7823 nodes long?
+    double standardDeviation;
+    int *histogram;
+};
+
+Stats *Stats_new();
+void Stats_delete(Stats* stats);
+bool Stats_logPath(Stats* stats, NodePtrVec* path);
+void Stats_calculate(Stats* stats);
+
+void testStats();
+
+#endif // STATISTICS_H

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/statistics.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * statistics.c
+ *
+ *  Created on: Sept 24, 2013
+ *      Author: Brian "Rig" Rigdon
+ */
+
+#include "statistics.h"
+#include <math.h>
+#include <limits.h>
+
+HistogramElement *HistogramElement_new(int length)
+{
+    HistogramElement *new = malloc(sizeof(HistogramElement));
+    if ( !new )
+        return NULL;
+    new->length = length;
+    new->count = 1;
+    new->next = NULL;
+    return(new);
+}
+
+bool HistogramElement_updateList(HistogramElement **head, int length)
+{
+    HistogramElement **prev = NULL;
+    HistogramElement *current = NULL;
+    HistogramElement *new = NULL;
+    bool histogramInsert = false;
+    
+    prev = head;
+    for ( current = *head; current != NULL; current = current->next )
+    {
+        if ( current->length < length )
+        {
+            prev = &current->next;
+            continue; /* iterate down the histogram linked list */
+        }
+        if ( current->length == length )
+        {
+            ++current->count;
+            histogramInsert = true;
+            break;
+        }
+        if ( current->length > length )
+        {
+            /* we are logging a new length, need to allocate and insert */
+            new = HistogramElement_new(length);
+            if ( ! new )
+                return(false);
+            new->next = current;
+            (*prev) = new;
+            histogramInsert = true;
+            break;
+        }
+    }
+    
+    if ( !histogramInsert ) /* this element belongs at the end of the chain */
+    {
+        (*prev) = HistogramElement_new(length);
+        if ( (*prev) == NULL )
+            return(false);
+    }
+
+    return(true);
+}
+
+Stats *Stats_new()
+{
+    Stats* new = malloc(sizeof(Stats));
+    if ( new )
+    {
+        new->pathLengths = IntVector_new(16); // Arbitrary, multiple of 8 for vectorization
+        new->averageLength = 0.0;
+        new->standardDeviation = 0.0;
+        new->minLength = INT_MAX;
+        new->maxLength = 0;
+        new->histogram = NULL;
+        if ( new->pathLengths )
+            return(new);
+        else
+        {
+            free(new);
+            return(NULL);
+        }
+    }
+    else
+        return(NULL);
+}
+
+
+void Stats_delete(Stats* stats)
+{
+    if ( stats )
+    {
+        if ( stats->pathLengths )
+            free(stats->pathLengths);
+        free(stats);
+    }
+}
+
+
+bool Stats_logPath(Stats* stats, NodePtrVec* path)
+{
+//    bool histogramInsert = false;
+//    HistogramElement **prev = NULL;
+//    HistogramElement *hist = NULL;
+//    HistogramElement *new = NULL;
+    int length;
+    
+    if ( !stats || !stats->pathLengths || !path )
+        return(false);
+
+    length = path->contentSize;
+    if ( length < stats->minLength )
+        stats->minLength = length;
+    if ( length > stats->maxLength )
+        stats->maxLength = length;
+    return ( IntVector_insertEnd(stats->pathLengths, length) );
+}
+
+void Stats_calculate(Stats* stats)
+{
+    int i;
+    int length;
+    double sum;
+    double diff;
+    
+    /* a little basic error checking */
+    if ( !stats || !stats->pathLengths || stats->pathLengths == 0 )
+        return;
+    stats->histogram = calloc((stats->maxLength+1), sizeof(int));
+    if ( !stats->histogram )
+        return;
+    
+    for ( i = 0; i < stats->pathLengths->size; ++i )
+    {
+        if ( stats->pathLengths->vector[i] > 0 )
+        {
+            length = stats->pathLengths->vector[i];
+            sum += (double)length;
+            /* While we're iterating through the list, let's build our histogram... */
+            /* HistogramElement_updateList(&stats->histogram, length); */
+            stats->histogram[length] += 1;
+        }
+    }
+    if ( i > 0 )
+        stats->averageLength = sum / (double)i;
+    
+    sum = 0.0;
+    for ( i = 0; i < stats->pathLengths->size; ++i )
+    {
+        if ( stats->pathLengths->vector[i] > 0 )
+        {
+            diff = (double)stats->pathLengths->vector[i] - stats->averageLength;
+            sum += diff * diff; 
+        }
+    }
+    
+    if ( i > 0 )
+        stats->standardDeviation = sqrt(sum/(double)i);
+}
+
+
+void testStats()
+{
+    int i;
+    Stats *test = Stats_new();
+    NodePtrVec bogon;
+    
+    for ( i = 2; i < 10; ++i )
+    {
+        bogon.contentSize = i;
+        Stats_logPath(test,&bogon);
+    }
+    
+    /* Throw in some more silly data */
+    bogon.contentSize = 1;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 4;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 5;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 6;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 5;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 5;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 4;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 5;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 6;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 5;
+    Stats_logPath(test,&bogon);
+    bogon.contentSize = 5;
+    Stats_logPath(test,&bogon);
+    
+    Stats_calculate(test);
+    printf("avg: %f\nstd dev: %f\n", test->averageLength, test->standardDeviation);
+    printf("Histogram:\n");
+    for ( i = test->minLength; i < test->maxLength; ++i )
+    {
+        printf ("\tlength %d appeared %d times\n", i, test->histogram[i] );
+    }
+    
+}
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/systemCallMap.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * systemCallMap.h
+ *
+ *  Created on: Feb 5, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#ifndef SYSTEMCALLMAP_H_
+#define SYSTEMCALLMAP_H_
+
+#include <stdbool.h>
+#include "node.h"
+
+
+
+/* A signature is an array of character pointers. Signature arrays
+ * are terminated with a NULL pointer so we don't have to have an
+ * additional datum to contain the length of the array. To make
+ * the code more readable, we are using this typedef:
+ */
+typedef char **Signature; /* code must be careful to ensure NULL termination */
+
+
+/*
+ * SystemCallMapStruct specifies a label and all the nodes that are associated with
+ * that label. Currently, this is sub-optimal, managing via strcmp. If optimization
+ * is needed, that is left as an exercise for the future. We could see the future
+ * addition of hash values
+ */
+
+typedef struct SystemCallMapElementStruct SystemCallMapElement;
+
+struct SystemCallMapElementStruct
+{
+    char *label;
+    int index;
+    NodePtrVec *nodes;
+};
+
+SystemCallMapElement *SystemCallMapElement_new ( char *label, int initialSize ); /* Element constructor */
+void SystemCallMapElement_delete( SystemCallMapElement *trash ); /* Element destructor */
+
+
+
+
+/* The call map is actually a stack (managed like the STL deque) of SystemCallMapElements.
+ * It will insert up to its capacity, and then double its size (allocating a new space, copying
+ * and then freeing the old) when it grows beyond its capacity.
+ */
+
+typedef struct SystemCallMapStruct SystemCallMap;
+
+struct SystemCallMapStruct
+{
+    int contentSize;
+    int allocatedSize;
+    SystemCallMapElement **vector; /* a pointer to an array of pointers */
+};
+
+SystemCallMap *SystemCallMap_new( int initialSize );
+void SystemCallMap_delete( SystemCallMap *trash ); /* destructor for an ENTIRE MAP!!!  */
+
+/* insert checks to see if there is already an entry for the name passed in. If so,
+ * it appends the node to that map element. If not, a new element is created, the
+ * name is duplicated
+ */
+bool SystemCallMap_insert ( SystemCallMap *map, char *label, Node *node );
+
+
+/* Finds a list of nodes associated with a label. */
+NodePtrVec *SystemCallMap_findLabeledNodes( SystemCallMap *systemCalls, char *label );
+
+/* Returns the index of a given label */
+int SystemCallMap_getLabelIndex( SystemCallMap *map, char *label );
+
+/*
+ * Determines if all the labels in a given signature are represented
+ * within this graph. If not, we know the search will fail. There's
+ * gotta be a better name for this...
+ */
+bool SystemCallMap_signatureRepresented( SystemCallMap *map, Signature signature );
+
+#endif /* SYSTEMCALLMAP_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/systemCallMap.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * systemCallMap.c
+ *
+ *  Created on: Feb 5, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#include "systemCallMap.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Element constructor */
+SystemCallMapElement *SystemCallMapElement_new ( char *label, int initialSize )
+{
+    SystemCallMapElement *element = malloc ( sizeof( SystemCallMapElement ) );
+    if ( element )
+    {
+        element->label = strdup ( label );
+        element->index = -1; /* Set by the insertion algorithm */
+        if ( !element->label )
+        {
+            free( element );
+            return( NULL );
+        }
+        element->nodes = NodePtrVec_new( initialSize );
+        if ( !element->nodes )
+        {
+            free( element->label );
+            free( element );
+            return( NULL );
+        }
+    }
+
+    return( element );
+}
+
+/* Element destructor */
+void SystemCallMapElement_delete( SystemCallMapElement *trash )
+{
+    /* free the mallocs! */
+    if ( trash )
+    {
+        if ( trash->label )
+            free( trash->label );
+        NodePtrVec_delete ( trash->nodes );
+    }
+}
+
+
+
+
+
+/* Constructor */
+SystemCallMap *SystemCallMap_new ( int initialSize )
+{
+    SystemCallMap *map = NULL;
+    SystemCallMapElement **vector = NULL;
+
+    if ( initialSize <= 0 )
+        return NULL;
+
+    vector = malloc(  initialSize * sizeof( SystemCallMapElement* ) );
+    if ( vector )
+    {
+        map = malloc ( sizeof( SystemCallMap ) );
+        if ( map )
+        {
+            map->allocatedSize = initialSize;
+            map->contentSize = 0;
+            map->vector = vector;
+        }
+        else
+            free( vector );
+    }
+
+    return map;
+}
+
+/* destructor for an ENTIRE MAP!!! */
+void SystemCallMap_delete( SystemCallMap *trash )
+{
+    int i;
+
+    /* basic error checking */
+    if ( !trash )
+        return;
+
+    for ( i = 0; i < trash->contentSize; ++i )
+    {
+        SystemCallMapElement_delete( trash->vector[i] );
+    }
+}
+
+
+
+/* setter */
+bool SystemCallMap_insert ( SystemCallMap *map, char *label, Node *node )
+{
+    int i = 0;
+    SystemCallMapElement *newElement = NULL;
+    bool success = false;
+
+    /* Some basic error checking */
+    if ( !map || !label || !node )
+        return( false );
+
+    /* See if this label has already been implemented */
+    for ( i = 0; i < map->contentSize; ++i )
+    {
+        if ( strcmp( label, map->vector[i]->label ) == 0 )
+        {
+            /* found it! */
+            node->label = map->vector[i]->label;
+            node->labelIdx = i;
+            return( NodePtrVec_push( map->vector[i]->nodes, node ) );
+        }
+    }
+
+    /* If we make it here, we have a new label */
+    if ( map->contentSize == map->allocatedSize )
+    {
+        /* Full up! Need a new vector */
+        map->vector = realloc( map->vector, (map->allocatedSize*2 * sizeof( SystemCallMapElement * )) );
+        if ( map->vector )
+        {
+            map->allocatedSize *= 2;
+        }
+        else
+            return( false );
+    }
+
+    newElement = SystemCallMapElement_new( label, 8 ); /* arbitrary size of 8 */
+    if ( !newElement )
+        return( false );
+
+    success = NodePtrVec_push( newElement->nodes, node );
+    if ( !success )
+        SystemCallMapElement_delete( newElement );
+
+    node->label = newElement->label;
+    node->labelIdx = newElement->index = map->contentSize; /* Does newElement really need the index? */
+    map->vector[map->contentSize] = newElement;
+    map->contentSize += 1;
+
+    return( true );
+
+}
+
+
+
+/* Finds all nodes associated with a label. */
+NodePtrVec *SystemCallMap_findLabeledNodes( SystemCallMap *systemCalls, char *label )
+{
+    int i;
+
+    /* Debug --> * /
+    printf("Inside SystemCallMap_findLabeledNodes, label: %s\n", label);
+    / *<-- end debug */
+    if ( !systemCalls || !label )
+        return( NULL );
+
+    for( i = 0; i < systemCalls->contentSize; ++i )
+    {
+        /* Debug -->* /
+        printf("\t...checking against %s...\n", systemCalls->vector[i]->label);
+        / * <-- end debug */
+        if ( strcmp( label, systemCalls->vector[i]->label ) == 0 )
+            return( systemCalls->vector[i]->nodes );
+    }
+
+    /* Debug --> * /
+    printf("\tleaving SystemCallMap_findLabeledNodes, nothing found.\n");
+    / *<-- end debug */
+    return( NULL );
+}
+
+/* Returns the index of a given label */
+int SystemCallMap_getLabelIndex( SystemCallMap *map, char *label )
+{
+    int i;
+
+    /* See if this label has already been implemented */
+    for ( i = 0; i < map->contentSize; ++i )
+    {
+        if ( strcmp( label, map->vector[i]->label ) == 0 )
+        {
+            return( i );
+        }
+    }
+
+    /* If we made it here, this label is not represented */
+    return( -1 );
+}
+
+
+/*
+ * Determines if all the labels in a given signature are represented
+ * within this graph. If not, we know the search will fail. There's
+ * gotta be a better name for this...
+ */
+bool SystemCallMap_signatureRepresented( SystemCallMap *map, Signature signature )
+{
+    int i;
+    bool foundByLabel = true;
+
+    for ( i = 0; signature[i] != NULL && foundByLabel; ++i )
+    {
+        /* if the signature is in the map, its index will be >=0 */
+        if ( SystemCallMap_getLabelIndex( map, signature[i] ) < 0 )
+            foundByLabel = false;
+    }
+
+    return( foundByLabel );
+}
+
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/utils.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * utils.h
+ *
+ *  Created on: Jan 10, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#ifndef UTILS_H_
+#define UTILS_H_
+
+#include "graph.h"
+#include "systemCallMap.h"
+#include "searchDiagram.h"
+void edgeListPrettyPrint( EdgeList *edges, int depth, char *header );
+void nodeListPrettyPrint( NodeList *nodes, int depth, char *separator, bool multiLine );
+void graphPrettyPrint( Graph *graph );
+void systemCallMapPrettyPrint( SystemCallMap *map );
+void printStack ( NodePtrVec *stack );
+bool testGraph();
+void testStack();
+
+void searchDiagramPrettyPrint ( SearchDiagram *diagram );
+
+#endif /* UTILS_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/utils.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+
+/*
+ * utils.c
+ *
+ *  Created on: Jan 10, 2013
+ *      Author: Brian "Rig" Rigdon, Marcus Smith, Samuel Mulder
+ */
+
+#include "utils.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+void edgeListPrettyPrint( EdgeList *edges, int depth, char *header )
+{
+    int i;
+    for ( i = 0; i < depth; ++i )
+        printf( "\t" );
+    printf( "%s: ", header );
+    for ( ; edges != NULL; edges = edges->nextEdge )
+        printf( " %d,", edges->targetNodeId );
+    printf( "\n" );
+}
+
+
+void nodeListPrettyPrint( NodeList *nodes, int depth, char *separator, bool multiLine )
+{
+    int i;
+
+    if ( !nodes )
+        return;
+
+    if ( nodes->node )
+        printf( "%d", nodes->node->id );
+    if ( nodes->nextNode )
+    {
+        if ( multiLine )
+        {
+            printf( "\n" );
+            for ( i = 0; i < depth; ++i )
+            {
+                printf( "    " );
+            }
+        }
+        printf( "%s", separator );
+        nodeListPrettyPrint( nodes->nextNode, depth + 1, separator, multiLine );
+    }
+    else
+        printf( "\n" );
+}
+
+
+void graphPrettyPrint ( Graph *graph )
+{
+    NodeList *outerPtr;
+    NodeList *innerPtr;
+
+    for ( outerPtr = graph->outerNodes;
+            outerPtr != NULL;
+            outerPtr = outerPtr->nextNode )
+    {
+        printf( "Outer Node: %d, idx: %d, label: %s (%d)\n", outerPtr->node->id,
+                outerPtr->node->nodeCount, outerPtr->node->label ? outerPtr->node->label : "none",
+                outerPtr->node->labelIdx );
+        edgeListPrettyPrint( outerPtr->node->edges, 1, "Edges" );
+        /* Deprecated: edgeListPrettyPrint( outerPtr->node->entranceNodes, 1, "EntranceNodes" ); */
+        for ( innerPtr = outerPtr->node->interiorNodes;
+                innerPtr != NULL;
+                innerPtr = innerPtr->nextNode )
+        {
+            printf( "\tInner Node: %d\n", innerPtr->node->id );
+            edgeListPrettyPrint( innerPtr->node->edges, 2, "Edges" );
+        }
+    }
+
+    printf ( "\n\n" );
+}
+
+
+void systemCallMapPrettyPrint( SystemCallMap *map )
+{
+    SystemCallMapElement *element = NULL;
+    int i = 0;
+    int j = 0;
+
+    if ( !map )
+        return;
+
+    for ( i = 0; i < map->contentSize; ++i )
+    {
+        element = map->vector[i];
+        printf( "'%s'\n\t:", element->label );
+         for ( j = 0; element->nodes && j < element->nodes->contentSize; ++j )
+        {
+            printf( "%d", element->nodes->vector[j]->id );
+            if ( j < element->nodes->contentSize-1 )
+                printf( ", " );
+            else
+                printf( "\n\n" );
+        }
+
+    }
+
+    printf( "\t%d total System Call Map elements\n", map->contentSize );
+}
+
+bool testGraph()
+{
+    /* Build it and see if it will get made */
+    Graph *graph = malloc( sizeof( Graph ) );
+    Node *outerNode1 = Node_new( 10, 0 );
+    Node *outerNode2 = Node_new( 20, 1 );
+    Node *innerNode11 = Node_new( 11, 2 );
+    Node *innerNode12 = Node_new( 12, 3 );
+    Node *innerNode21 = Node_new( 21, 4 );
+    Node *innerNode22 = Node_new( 22, 5 );
+    Node *innerNode23 = Node_new( 23, 6 );
+
+    if ( !graph ) return( false );
+
+    Graph_addOuterNode( graph, outerNode1 );
+    Graph_addOuterNode( graph, outerNode2 );
+
+    Node_addInteriorNode( outerNode1, innerNode11 );
+    Node_addInteriorNode( outerNode1, innerNode12 );
+
+    Node_addInteriorNode( outerNode2, innerNode21 );
+    Node_addInteriorNode( outerNode2, innerNode22 );
+    Node_addInteriorNode( outerNode2, innerNode23 );
+
+
+    /* Ok, let's print out the graph and see if it works */
+    graphPrettyPrint( graph );
+
+    return( true );
+}
+
+void printStack ( NodePtrVec *stack )
+{
+    if ( !stack ) return;
+    int i;
+    // printf ( "stack size %d out of %d max\n", stack->contentSize, stack->allocatedSize );
+    for ( i = 0; i < stack->contentSize; ++i )
+    {
+        printf("%d", stack->vector[i]->id );
+        fflush(stdout);
+        if ( stack->vector[i]->label )
+        {
+            printf( "(%s)", stack->vector[i]->label );
+            fflush(stdout);
+        }
+        if ( i != stack->contentSize-1 )
+        {
+            printf ( " : " );
+            fflush(stdout);
+        }
+    }
+    printf( "\n" );
+    fflush(stdout);
+}
+
+void testStack()
+{
+    /* This was written when the stack was storing integers
+    int a, b, c, d, e;
+    printf ( "\n\nTesting stack operations" );
+    NodePtrVec *vector = Stack_new(3);
+    if ( !vector )
+    {
+        printf( "stack allocation failed\n" );
+        return;
+    }
+    Stack_push( vector, 1 );
+    Stack_push( vector, 2 );
+    printStack( vector );
+    Stack_push( vector, 3 );
+    printStack( vector );
+    Stack_push( vector, 4 );
+    printStack( vector );
+
+    printf ( "\n2 %s in the stack\n", Stack_find( vector, 2 ) ? "is" : "is not" );
+    printf ( "5 %s in the stack\n\n", Stack_find( vector, 5 ) ? "is" : "is not" );
+
+    printf ( "\n4 %s in the stack\n", Stack_findReverse( vector, 4 ) ? "is" : "is not" );
+    printf ( "45 %s in the stack\n\n", Stack_findReverse( vector, 45 ) ? "is" : "is not" );
+
+    a = Stack_pop( vector );
+    printStack( vector );
+    b = Stack_pop( vector );
+    c = Stack_pop( vector );
+    d = Stack_pop( vector );
+    e = Stack_pop( vector );
+    printStack( vector );
+    printf ( "%d, %d, %d, %d, %d\n", a, b, c, d, e );
+    */
+}
+
+
+/* The below code gives compile warnings about the size difference
+ * between pointers and ints. Since this doesn't impact execution, 
+ * I am not going to chase down a fix.
+ */
+void searchDiagramPrettyPrint ( SearchDiagram *diagram )
+{
+#if 0
+    SearchDiagram *node;
+    EdgeReferences *edge;
+
+    for ( node = diagram; node != NULL && node->node != NULL; ++node )
+    {
+        printf ( "Node %x -> %d\n", (unsigned int)node, node->node->id );
+        if ( node->edgeReferenceArray )
+        {
+            printf ( "\t%x\n", (int)node->edgeReferenceArray );
+            for ( edge = node->edgeReferenceArray; edge->edgeTarget != NULL; ++edge )
+            {
+                printf ( "\t\tEdge (target %d) -> %x\n",
+                         edge->edgeTarget->id, (int)edge->targetNodeEdges );
+            }
+        }
+
+    }
+#endif
+}
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/vectorUtils.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+/*
+ * vectorUtils.h
+ *
+ *  Created on: Jun 21, 2013
+ *      Author: J. Brian Rigdon
+ */
+
+#ifndef VECTORUTILS_H_
+#define VECTORUTILS_H_
+
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "node.h"
+
+/* The IntVector is sort of a C version of std::vector<int> */
+typedef struct IntVectorStruct IntVector;
+struct IntVectorStruct
+{
+    int size; /* number of integers actively stored */
+    int allocatedSize;
+    int *vector;
+};
+
+IntVector *IntVector_new(int size); /* constructor */
+void IntVector_delete(IntVector *trash); /* destructor */
+#define IntVector_clear(intVectorPtr) (intVectorPtr->size = 0)
+#define IntVector_size(intVectorPtr) (intVectorPtr->size)
+bool IntVector_insertEnd(IntVector *vector, int datum);
+
+/*
+ * parse space-delimited null-terminated string into an IntVector.
+ * Returns the number of integers collected
+ */
+int IntVector_createFromString(IntVector *vector, char *inputString);
+
+
+
+
+
+/* The CharVector is sort of a C version of std::vector<char> */
+typedef struct CharVectorStruct CharVector;
+struct CharVectorStruct
+{
+    int size; /* number of integers actively stored */
+    int allocatedSize;
+    char *string;
+};
+
+CharVector *CharVector_new(int size); /* constructor */
+void CharVector_delete(CharVector *trash); /* destructor */
+bool CharVector_insertEnd(CharVector *vector, char c);
+int CharVector_getLineFromFile(CharVector *vector, FILE *input);
+
+
+
+
+
+
+/* -------------------------------------------
+ * Node Pointer Vector Definitions
+ *
+ *      NodePtrVec are an alternative storage mechanism to the Node Lists.
+ *      The Vector is single ended, with a push and a pop. It maintains
+ *      a count of contained Node pointers, the maximum allocated size for
+ *      the storage and a pointer to the array of Node pointers. When the
+ *      contained size reaches the maximum, another piece of memory, we
+ *      realloc for twice the size. This is patterned after STL vectors
+ */
+
+
+
+/* A simple, sized vector class. The vector is initially created with a specified size
+ * even though it holds nothing. Each push increments a counter (pops decrement) until
+ * it reaches its initial size. The next push will be slow, because the vector needs
+ * to grow. At that point, we realloc with DOUBLE the size of the original vector. If
+ * successful, the last datagram is inserted in the end of the vector.
+ */
+
+typedef struct NodePtrVecStruct NodePtrVec;
+
+struct NodePtrVecStruct
+{
+    int contentSize;    // the number of elements currently in the vector
+    int allocatedSize;  // the amount (in sizeof int) currently allocated for this vector
+    Node **vector;       // a pointer to the actual data (array of node pointers).
+};
+
+
+NodePtrVec *NodePtrVec_new(int initialSize); /* create a new vector allocating specified size */
+void NodePtrVec_delete(NodePtrVec *trash); /* destructor */
+NodePtrVec *NodePtrVec_copy(NodePtrVec *from, bool exact_copy); /* creates duplicate vector (not duplicate nodes!) */
+
+/* pushes the element if it can. If a memory allocation is required but
+ * fails - false is returned
+ */
+bool NodePtrVec_push(NodePtrVec *vector, Node *node);
+Node * NodePtrVec_pop(NodePtrVec *vector); /* returns the top item and decrements. If empty, we return -1 */
+
+/* Screams through the vector from bottom to top to find the specified element. If found,
+ * returns true.
+ */
+bool NodePtrVec_find(NodePtrVec *vector, Node *node);
+
+/* Screams through the vector from top to bottom to find the specified element. If found,
+ * returns true.
+ */
+bool NodePtrVec_findReverse(NodePtrVec *vector, Node *node);
+
+/* Appends the second vector to the first. If the "keepFirst" flag is set, the
+ * entire second vector is appended to the first. Otherwise, the [0] element of
+ * the second vector is skipped. This is useful when the last element of the
+ * first vector is identical to the first element of the second vector, and
+ * we don't want duplication. (And who, really, wants duplication? Really, who
+ * wants duplication?)
+ */
+void NodePtrVec_appendVectors(NodePtrVec *first, NodePtrVec *second, bool keepFirst);
+
+
+/* -------------------------------------------
+ * And a vector of Node Pointer Vectors
+ *
+ * Results from the searches are presented as NodePtrVectors. To store a bunch of these
+ * we are defining a vector of these vectors.
+ */
+
+typedef struct NodeVecVecStruct NodeVecVec;
+
+struct NodeVecVecStruct
+{
+    int contentSize;
+    int allocatedSize;
+    NodePtrVec **vector;
+};
+
+NodeVecVec *NodeVecVec_new(int initialSize); /* constructor */
+void NodeVecVec_delete(NodeVecVec* trash); /* destructor */
+bool NodeVecVec_insert(NodeVecVec* vector, NodePtrVec* path); /* puts a copy of "path" at the end of the vector */
+
+#endif /* VECTORUTILS_H_ */

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/vectorUtils.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+/*
+ * vectorUtils.c
+ *
+ *  Created on: Jun 21, 2013
+ *      Author: jbrigdo
+ */
+
+#include "vectorUtils.h"
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+
+/* --------
+ * IntVector Methods
+ */
+
+/* constructor */
+IntVector *IntVector_new( int size )
+{
+    IntVector *new = malloc( sizeof(IntVector) );
+    if ( new )
+    {
+        int *vector = malloc ( size * sizeof(int) );
+        if ( vector )
+        {
+            new->vector = vector;
+            new->size = 0;
+            new->allocatedSize = size;
+            return( new );
+        }
+        else
+        {
+            free( new );
+            return( NULL );
+        }
+    }
+    else
+        return( NULL );
+}
+
+/* destructor */
+void IntVector_delete(IntVector *trash)
+{
+    if ( trash )
+    {
+        if ( trash->vector )
+            free( trash->vector );
+        free( trash );
+    }
+}
+
+/* inserts a new integer at the tail of the vector */
+bool IntVector_insertEnd(IntVector *vector, int datum)
+{
+    int current = 0;
+    int max = 0;
+
+    /* some basic error checking */
+    if ( !vector )
+        return( false );
+
+    current = vector->size;
+    max = vector->allocatedSize;
+
+    if ( current == max ) /* we're full */
+    {
+        vector->vector = realloc( vector->vector, 2*max*sizeof(int) );
+        if ( vector->vector )
+        {
+            vector->allocatedSize = 2*max;
+        }
+        else
+        {
+            fprintf( stderr, "\n\nIntVector_insertEnd failed realloc size = %d\n", current*2 );
+            return( false );
+        }
+    }
+
+    vector->vector[current] = datum;
+    vector->size += 1;
+    return( true );
+}
+
+/*
+ * A utility method that takes an input string to the next number. If it currently
+ * points to a number, we iterate past that number, past any whitespace or non-number
+ * and point to the first digit character we find. If input currently points a non-
+ * digit character, we find the next digit character and return a pointer to it. If
+ * no non-digit character is found with these rules, we return null.
+ */
+static char *findNextNumber(char *input)
+{
+    if ( isdigit( (int)input[0] ) )
+    {
+        /* scream through the string to find a non-digit */
+        ++input;
+        while ( isdigit( (int)input[0] ) && *input != '\0' )
+            ++input;
+        if ( input[0] == '\0' )
+            return( NULL );
+        else
+            /* now find the next digit */
+            while ( !isdigit( (int)input[0] ) && *input != '\0' )
+                ++input;
+        if ( input[0] == '\0' )
+            return(NULL);
+        else
+            return(input);
+    }
+    else
+    {
+        /* find the first digit character */
+        do {
+            if ( input[0] == '\0' )
+                return(NULL);
+            ++input;
+        } while ( !isdigit( (int)input[0] ) );
+        return(input);
+    }
+}
+
+/*
+ * parse space-delimited null-terminated string into an IntVector.
+ * Returns the number of integers collected
+ */
+int IntVector_createFromString(IntVector *vector, char *inputString)
+{
+    int dataCount = 0;
+    int datum;
+
+    /* make sure we have valid pointers passed in*/
+    if ( !vector || !inputString )
+        return(0);
+
+    /* make sure we're pointing to a digit */
+    if ( !isdigit((int)inputString[0]))
+    {
+        inputString = findNextNumber(inputString);
+    }
+
+    /* ok, at this point, we know we're pointing at a number */
+    while (inputString) /* set to NULL when there are no more numbers. */
+    {
+        datum = atoi(inputString);
+        inputString = findNextNumber(inputString);
+        if ( !IntVector_insertEnd(vector, datum) )
+            return(0); /* realloc failure */
+        ++dataCount;
+    }
+
+    return(dataCount);
+}
+
+
+
+
+/* constructor */
+CharVector *CharVector_new(int size)
+{
+    CharVector *new = malloc( sizeof(CharVector) );
+    if ( new )
+    {
+        char *string = malloc ( size * sizeof(char) );
+        if ( string )
+        {
+            new->string = string;
+            new->size = 0;
+            new->allocatedSize = size;
+            return( new );
+        }
+        else
+        {
+            free( new );
+            return( NULL );
+        }
+    }
+    else
+        return( NULL );
+}
+
+/* destructor */
+void CharVector_delete( CharVector *trash )
+{
+    if ( trash )
+    {
+        if ( trash->string )
+            free( trash->string );
+        free( trash );
+    }
+}
+
+
+bool CharVector_insertEnd( CharVector *vector, char c )
+{
+    int size = 0;
+    int max = 0;
+
+    /* some basic error checking */
+    if ( !vector )
+        return( false );
+
+    size = vector->size;
+    max = vector->allocatedSize;
+
+    if ( size == max ) /* we're full */
+    {
+        vector->string = realloc( vector->string, 2*size*sizeof(char) );
+        if ( vector->string )
+        {
+            vector->allocatedSize = size*2;
+        }
+        else
+        {
+            fprintf( stderr, "\n\nIntVector_insertEnd failed realloc size = %d\n", size*2 );
+            return( false );
+        }
+    }
+
+    vector->string[size] = c;
+    vector->size += 1;
+    return( true );
+}
+
+
+int CharVector_getLineFromFile( CharVector *vector, FILE *input )
+{
+    bool notDoneYet = true;
+    char c = '\0';
+
+    /* Some basic error checking */
+    if ( !vector || !input )
+        return( -1 );
+
+    vector->size = 0; /* reset the vector prior to filling */
+
+    /* get to the next digit */
+    do {
+        c = fgetc( input );
+        if ( feof( input ) || c == '\n' )
+            notDoneYet = false;
+        else
+            if ( ! CharVector_insertEnd( vector, c ) )
+                return( -1 ); /* CharVector_insertEnd reached a memory limit. Fail */
+    } while ( notDoneYet );
+
+    /* make the data a c-string */
+    if ( ! CharVector_insertEnd( vector, '\0' ) )
+        return( -1 ); /* CharVector_insertEnd reached a memory limit. Fail */
+    return( vector->size );
+}
+
+
+
+/* -------------------------------------------
+ * Node Pointer Vector Method Definitions
+ *
+ */
+
+/* create a new vector allocating specified size */
+NodePtrVec *NodePtrVec_new( int initialSize )
+{
+    NodePtrVec *newVector;
+    Node **vector; /* an array of pointers */
+
+    vector = malloc ( initialSize * sizeof(Node *) );
+    if ( !vector )
+    {
+        printf ( "Malloc failure in NodePtrVec creation\n" );
+        return( NULL );
+    }
+
+    newVector =  malloc ( sizeof(NodePtrVec) );
+    if ( !newVector )
+    {
+        free(vector);
+        printf ( "Malloc failure in NodePtrVec storage creation\n" );
+        return( NULL );
+    }
+
+    newVector->allocatedSize = initialSize;
+    newVector->contentSize = 0;
+    newVector->vector = vector;
+    return( newVector );
+}
+
+
+
+/* destructor */
+void NodePtrVec_delete( NodePtrVec *trash )
+{
+    if ( trash )
+    {
+        if ( trash->vector )
+            free(trash->vector);
+        free(trash);
+    }
+}
+
+
+/* creates duplicate vector (not duplicate nodes!). If exact_copy is true, the
+ * new vector is the same size as the copied one. If false, then only enough
+ * room to hold the copy is allocated.
+ */
+NodePtrVec *NodePtrVec_copy(NodePtrVec *from, bool exact_copy)
+{
+    int i;
+
+    if ( !from )
+        return NULL;
+
+    NodePtrVec *to = exact_copy ? NodePtrVec_new(from->allocatedSize)
+                                : NodePtrVec_new(from->contentSize);
+    if ( !to )
+        return NULL;
+
+    for ( i = 0; i < from->contentSize; ++i )
+        to->vector[i] = from->vector[i];
+    to->contentSize = from->contentSize;
+    return to;
+}
+
+/* pushes the element if it can. If a memory allocation is required but
+ * fails - false is returned
+ */
+bool NodePtrVec_push( NodePtrVec *vector, Node *node )
+{
+    int current;
+    int max;
+
+    /* some basic error checking */
+    if ( !vector ) return false;
+
+    current = vector->contentSize;
+    max = vector->allocatedSize;
+
+    /* see if our vector is full */
+    if ( current == max )
+    {
+        vector->vector = realloc( vector->vector, 2*max * sizeof(Node *) );
+        if ( vector->vector )
+        {
+            vector->allocatedSize = 2*max;
+        }
+        else
+        {
+            printf ( "\n\nNodePtrVec_push failed malloc(%d). Node: %d", 2*max, node->id );
+            if ( node->label )
+                printf ( ", label: %s\n", node->label );
+            else
+                printf ( "\n\n" );
+            return false;
+        }
+    }
+
+    /* do the actual pushing */
+    vector->vector[current] = node;
+    vector->contentSize += 1;
+
+    return true;
+}
+
+/* returns the top item and decrements. What do we do to define empty? */
+Node * NodePtrVec_pop( NodePtrVec *vector )
+{
+    Node *top = NULL;
+
+    /* some basic error checking */
+    if ( !vector ) return NULL;
+
+    if ( vector->contentSize > 0 )
+    {
+        vector->contentSize -= 1;
+        top = vector->vector[vector->contentSize];
+    }
+
+    return top;
+}
+
+/* Screams through the vector from bottom to top to find the specified element. If found,
+ * returns true.
+ */
+bool NodePtrVec_find( NodePtrVec *vector, Node *node )
+{
+    int i;
+
+    /* some basic error checking */
+    if ( !vector ) return false;
+
+    for ( i = 0; i < vector->contentSize; ++i )
+        if ( vector->vector[i] == node )
+            return true;
+
+    return false;
+}
+
+/* Screams through the vector from top to bottom to find the specified element. If found,
+ * returns true.  */
+bool NodePtrVec_findReverse( NodePtrVec *vector, Node *node )
+{
+    int i;
+
+    /* some basic error checking */
+    if ( !vector || !vector->vector || !node ) return false;
+
+    for ( i = vector->contentSize-1; i >= 0; --i )
+        if ( vector->vector[i] == node )
+            return true;
+
+    return false;
+}
+
+
+/* Appends the second vector to the first. If the "keepFirst" flag is set, the
+ * entire second vector is appended to the first. Otherwise, the [0] element of
+ * the second vector is skipped. This is useful when the last element of the
+ * first vector is identical to the first element of the second vector, and
+ * we don't want duplication. (And who, really, wants duplication? Really, who
+ * wants duplication?)
+ */
+void NodePtrVec_appendVectors ( NodePtrVec *first, NodePtrVec *second, bool keepFirst )
+{
+    int i;
+
+    /* Some basic error checking */
+    if ( !first || !second )
+        return;
+
+    if ( keepFirst )
+        i = 0;
+    else
+        i = 1;
+
+    for ( ; i < second->contentSize; ++i )
+        NodePtrVec_push( first, second->vector[i] );
+}
+
+
+
+/* -------------------------------------------
+ * Node Vec Vec Method definitions
+ *
+ * (vector of Node Pointer Vectors )
+ */
+
+/* create a new vector allocating specified size */
+NodeVecVec *NodeVecVec_new( int initialSize )
+{
+    NodeVecVec *newVector;
+    NodePtrVec **vector; /* an array of pointers */
+
+    vector = malloc ( initialSize * sizeof(NodePtrVec *) );
+    if ( !vector )
+    {
+        printf ( "Malloc failure in NodeVecVec storage creation\n" );
+        fflush(stdout);
+        return( NULL );
+    }
+
+    newVector =  malloc ( sizeof(NodeVecVec) );
+    if ( !newVector )
+    {
+        free(vector);
+        printf ( "Malloc failure in NodeVecVec creation\n" );
+        fflush(stdout);
+        return( NULL );
+    }
+
+    newVector->allocatedSize = initialSize;
+    newVector->contentSize = 0;
+    newVector->vector = vector;
+    return( newVector );
+}
+
+
+
+/* destructor */
+void NodeVecVec_delete( NodeVecVec *trash )
+{
+    int i;
+    if ( trash )
+    {
+        for ( i = 0; i < trash->contentSize; ++i )
+            NodePtrVec_delete(trash->vector[i]);
+        if ( trash->vector )
+            free(trash->vector);
+        free(trash);
+    }
+}
+
+
+/* pushes a copy of the element if it can. If a memory allocation is required but
+ * fails - false is returned
+ */
+bool NodeVecVec_insert( NodeVecVec *vector, NodePtrVec *path )
+{
+    int current;
+    int max;
+    NodePtrVec *copy = NodePtrVec_copy(path,false);
+
+    /* some basic error checking */
+    if ( !vector || !path || !copy ) return false;
+
+    current = vector->contentSize;
+    max = vector->allocatedSize;
+
+    /* see if our vector is full */
+    if ( current == max )
+    {
+        vector->vector = realloc( vector->vector, 2*max * sizeof(Node *) );
+        if ( vector->vector )
+        {
+            vector->allocatedSize = 2*max;
+        }
+        else
+        {
+            printf ( "\n\nNodeVecVec_push failed malloc\n" );
+            fflush(stdout);
+            return false;
+        }
+    }
+
+    /* do the actual pushing */
+    vector->vector[current] = copy;
+    vector->contentSize += 1;
+
+    return true;
+}
+
+
+

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/yaml.h

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+/*
+ * yaml.h
+ *
+ *  Created on: Jun 21, 2013
+ *      Author: J. Brian Rigdon
+ */
+ 
+ #ifndef YAML_H
+ #define YAML_H
+ 
+ void YAMLOpen();
+ void YAMLClose();
+ void YAMLWriteString(char *tag, char *data);
+ void YAMLWriteInt(char *tag, int data);
+ void YAMLWriteDouble(char *tag, double data);
+ void YAMLWriteFloat(char *tag, float data);
+ 
+ #endif /* YAML_H */
 No newline at end of file

test-suite/trunk/MultiSource/Benchmarks/DOE-ProxyApps-C/Pathfinder/yaml.c

+/*************************************************************************
+ *
+ *        PathFinder: finding a series of labeled nodes within a
+ *                two-layer directed, cyclic graph.
+ *               Copyright (2013) Sandia Corporation
+ *
+ * Copyright (2013) Sandia Corporation. Under the terms of Contract 
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
+ * retains certain rights in this software.
+ *
+ * This file is part of PathFinder.
+ * 
+ * PathFinder is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * PathFinder is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PathFinder.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Questions? Contact J. Brian Rigdon ([e-mail])
+ *
+ */
+ 
+/*
+ * yaml.h
+ *
+ *  Created on: Jun 21, 2013
+ *      Author: J. Brian Rigdon
+ */
+ 
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include "yaml.h"
+static FILE *output = NULL;
+
+/* This file doesn't yet do a true key/element pair clustering the way YAML is
+ * intended to do. It is currently a minimalistic approach to output the most
+ * important data from the run.
+ */
+ 
+/* In case configuration info isn't passed in... */
+#ifndef CXXFLAGS
+#define CXXFLAGS "unknown"
+#endif
+#ifndef CXXVERSION
+#define CXXVERSION "unknown"
+#endif
+
+
+
+
+void YAMLOpen()
+{
+    time_t rawTime;
+    struct tm *timeinfo = NULL;
+    char *fileName = calloc(200, sizeof(char));
+    char *timeStr = calloc(200, sizeof(char));
+    
+    
+    time(&rawTime);
+    timeinfo = localtime(&rawTime);
+
+    if ( output != NULL || fileName==NULL || timeStr==NULL || timeinfo == NULL )
+        return;
+
+    sprintf(fileName, "PathFinder_%d-%d-%d_%d-%d-%d.yaml", timeinfo->tm_year+1900, timeinfo->tm_mon+1,
+        timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
+    sprintf(timeStr, "%d/%d/%d, %d:%d:%d", timeinfo->tm_year+1900, timeinfo->tm_mon+1,
+        timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
+    printf("\nWriting YAML: %s\n\n", fileName);
+
+    /* static data - no need to free(timeinfo); */
+    
+    output = fopen(fileName, "w");
+    if ( output != NULL )
+    {
+        YAMLWriteString("Mini-Application Name", "PathFinder");
+        YAMLWriteString("Mini-Application Version", "1.0.0");
+        YAMLWriteString("Run Date/Time", timeStr);
+        YAMLWriteString("Compiler Version", CXXVERSION);
+        YAMLWriteString("Compiler Flags", CXXFLAGS);
+        
+#ifdef MPI
+        YAMLWriteString("MPI", "Yes");
+#else
+        YAMLWriteString("MPI", "No");
+#endif
+#ifdef OPENMP
+        YAMLWriteString("OpenMP", "Yes");
+        YAMLWriteString("Open MP Threads", getenv("OMP_NUM_THREADS"));
+#else
+        YAMLWriteString("OpenMP", "No");
+#endif
+
+    }
+}
+
+void YAMLClose()
+{
+    if ( output!=NULL )
+        fclose(output);
+}
+ 
+void YAMLWriteString(char *tag, char *data)
+{
+    if ( output!=NULL )
+        fprintf(output, "%s: %s\n", tag, data);
+}
+
+void YAMLWriteInt(char *tag, int data)
+{
+    if ( output!=NULL )
+        fprintf(output, "%s: %i\n", tag, data);
+}
+
+void YAMLWriteDouble(char *tag, double data)
+{
+    if ( output!=NULL )
+        fprintf(output, "%s: %lf\n", tag, data);
+}
+
+void YAMLWriteFloat(char *tag, float data)
+{
+    if ( output!=NULL )
+        fprintf(output, "%s: %f\n", tag, data);
+}
 No newline at end of file