Add dataset files

README.md

@@ -0,0 +1,12 @@
+---
+configs:
+- config_name: artifacts
+  data_files: artifacts.csv
+- config_name: traces
+  data_files: traces.csv
+- config_name: matrices
+  data_files: matrices.csv
+- config_name: train
+  data_files: train.csv
+
+---

artifacts.csv

@@ -0,0 +1,241 @@
+id,content,layer,summary
+FR01,FR 1 - Any software tool or application based on libwarc shall require just a single header file.,Functional Requirement,
+FR02,"FR 2 - The libwarc interfaces shall fully encapsulate and internal functionality, isolating by abstraction any tool or application based on libwarc from changes in the internal implementation.
+",Functional Requirement,
+FR03,"FR 3 - Libwarc shall provide a range of functions through a universal interface for creating each type of valid WARC-record, thus ensuring the resulting WARC files conform to the prevailing WARC standard
+",Functional Requirement,
+FR04,"FR 4 - For each type of WARC-record, a set of functions shall be made available to create/modify the records properties.",Functional Requirement,
+FR05,"FR 5 - Libwarc shall provide a range of functions through a universal interface for reading a range of valid WARC-records
+",Functional Requirement,
+FR06,FR 6 - Libwarc shall provide a stable Application Programme Interface (API) to handle WARCrecords as abstract objects (ADT),Functional Requirement,
+FR07,FR 7 - Libwarc shall provide ARC-record reader functionality Libwarc reader will thereby make read operations as simple as possible.,Functional Requirement,
+FR08,FR 8 - Libwarc shall provide a default iterator as a built-in function,Functional Requirement,
+FR09,FR 9 - Libwarc shall provide a records iterator to handle WARC-type records,Functional Requirement,
+FR10,"FR 10 - Libwarc shall provide a MIMES iterator to handle MIME-types payloads
+",Functional Requirement,
+FR11,FR 11 - Iterators can use exact pattern search or regex expressions,Functional Requirement,
+FR12,"FR 12 - Libwarc shall provide an abstract interface for iterators, to enable custom iterators",Functional Requirement,
+FR13,"FR 13 - Libwarc shall enable combinations of iterators to be used, i.e. composite iterators",Functional Requirement,
+FR14,"FR 14 - Libwarc shall be memory safe and manage dynamic memory internally
+",Functional Requirement,
+FR15,"FR 15 - Libwarc shall use disk-based working memory
+",Functional Requirement,
+FR16,FR 16 - Dynamic memory management shall be hidden inside libwarc,Functional Requirement,
+FR17,"FR 17 - Libwarc shall use gzip as the default compression format
+",Functional Requirement,
+FR18,"FR 18 - Libwarc shall provide a plug-in interface to enable use of alternative compression libraries, such as ""gzip2"", ""7zip"", etc.
+",Functional Requirement,
+FR19,FR 19 - Libwarc shall manage all write and read access,Functional Requirement,
+FR20,"FR 20 - WARC files shall be validated using a command line tool, ""w-validator"", which will enable validation or rejection of WARC files.",Functional Requirement,
+FR21,"FR 21 - WARC Browser shall provide an API that allows browsing of WARC files and associated CDX files via an HTTP server
+",Functional Requirement,
+FR22,FR 22 - WARC Browser shall support a rewriting interface,Functional Requirement,
+FR23,FR 23 - WARC Browser shall support a proxy-style interface,Functional Requirement,
+FR24,FR 24 - An Apache and Lighttp plug-in shall provide access to the libwarc API and WARC Browser over http,Functional Requirement,
+FR25,"FR 25 - It shall be possible to convert ARC files to WARC files using a command-line tool called ""arc2warc""
+",Functional Requirement,
+FR26,FR 26 - ARC to WARC conversions made by arc2warc shall be carried out according to a specification in a configuration file,Functional Requirement,
+FR27,"FR 27 - It shall be possible to collect HTTrack data from the directories output by HTTrack and write the data to WARC files
+",Functional Requirement,
+FR28,"FR 28 - It shall be possible to walk a wget mirror and write the data to WARC files
+",Functional Requirement,
+FR29,"FR 29 - It shall be possible to walk a curl directory and write the data to WARC files
+",Functional Requirement,
+FR30,"FR 30 - It shall be possible to collect arbitrary web content, such as html files, images etc. (for example from a web server document root directory), and write the data to WARC files
+",Functional Requirement,
+FR31,FR 31 - A Python script shall be made available to enable rapid development of WARC based solutions,Functional Requirement,
+FR32,"FR 32 - WARC extensions shall be released as a patch to each of the commands ""curl"", ""wget"", and ""httrack"" projects",Functional Requirement,
+FR33,"FR 33 - WARC extensions help content will be provided each of the commands ""curl"", ""wget"", and ""httrack""",Functional Requirement,
+FR34,"FR 34 - It shall be possible to identify WARC files using the unix ""file"" command",Functional Requirement,
+FR35,"FR 35 - It shall be possible to identify and validate WARC files using ""Jhove""",Functional Requirement,
+FR36,"FR 36 - A Jhove plugin module and an output handler shall be made available for WARC files
+",Functional Requirement,
+FR37,FR 37 - WARC files in various test-states shall be provided that test the Jhove deliverables,Functional Requirement,
+FR38,"FR 38 - The C library shall be implemented to be compatible with the Simplified Wrapper and Interface Generator (SWIG, http://www.swig.org) - a wrapper for libwarc C code to allow it to be called natively in a wide variety of languages.
+",Functional Requirement,
+FR39,"FR 39 - A Python interface shall be implemented
+",Functional Requirement,
+FR40,FR 40 - A Java interface shall be implemented,Functional Requirement,
+FR41,"FR 41 - An independent Java implementation of libwarc may be implemented
+",Functional Requirement,
+FR42,FR 42 - The functionality of the library shall be exposed in such a way as to fit the metaphors and paradigms of the implementation language,Functional Requirement,
+SRS01,"SRS 1 - There shall be a single entry point to libwarc, called ""warc.h"".
+",Specification,
+SRS02,"SRS 2 - The ""libwarc"" headers shall be structured in a hierarchical manner. The universal header ""warc.h"" will include all of them.
+",Specification,
+SRS03,"SRS 3 - It shall be possible for developers to access, modify and manipulate of all aspects of the WARC file format by including this single header file.",Specification,
+SRS04,"SRS 4 - The universal header ""warc.h"" shall ensure compatibility between all versions of libwarc.",Specification,
+SRS05,"SRS 5 - The universal header ""warc.h"" shall ensure that deprecated function calls and changes to the library are notified at compile time.
+",Specification,
+SRS06,"SRS 6 - The interfaces in libwarc shall ensure that any changes to the library, will not affect any tool or application based on libwarc.",Specification,
+SRS07,"SRS 7 - The universal header ""warc.h"" shall provide normalised interfaces to enable developers to create valid and compliant WARC-records, based on the definition in the ""ISO TC 46/SC 4 N 595"" standards document. The interfaces shall be made available to create WARC records of the following types:
+- ""warinfo""
+- ""response""
+- ""request""
+- ""metadata""
+- ""revisit""
+- ""conversion""
+- ""continuation""
+- ""resource""
+",Specification,
+SRS08,"SRS 8 - Each WARC-record shall be accessible via a peer C class of the same name.
+",Specification,
+SRS09,"SRS 9 - The attributes of each WARC-record, as per the ISO standard specification, shall have a corresponding attribute in its peer C class.
+",Specification,
+SRS10,"SRS 10 - Each peer class shall expose a set a class functions to read, write, and update attributes for the corresponding WARC-record.",Specification,
+SRS11,"SRS 11 - Libwarc shall provide an API describing (1) the set of data, and (2) the set of operations that can be performed on the data. The data types shall be abstract (abstract data types - ADT), to ensure independence of concrete implementations.
+",Specification,
+SRS12,"SRS 12 - It shall be possible to create a WARC-record using a constructor, which will returns an abstract handle to data representing the WARC-record.
+",Specification,
+SRS13,"SRS 13 - It shall be possible to release the WARC-record using a destructor.
+",Specification,
+SRS14,SRS 14 - Any operations on WARC-records shall be possible using functions accepting the abstract handle as an argument.,Specification,
+SRS15,SRS 15 -Libwarc shall include ADT objects to handle read operations on ARC-records,Specification,
+SRS16,"SRS 16 - Libwarc shall provide a generic iterator, to enable the developer to iterate over all WARCrecords and create an abstract WARC-document as a simple container
+",Specification,
+SRS17,"SRS 17 - Libwarc shall provide a WARC-record MIME-type iterator
+",Specification,
+SRS18,"SRS 18 - Libwarc shall provide a WARC-record-type iterator
+",Specification,
+SRS19,"SRS 19 - Libwarc's generic iterators may be customised for different purposes via callback handlers (i.e. hooks)
+",Specification,
+SRS20,SRS 20 - Libwarc's iterators may be combined into composite iterators to enable the developer to more than one search field,Specification,
+SRS21,"SRS 21 - Libwarc shall encapsulate and handle all memory management when processing WARCrecords.
+",Specification,
+SRS22,"SRS 22 - Developers using libwarc shall not be required to allocate/release memory directly, instead the developer shall use libwarc's object constructor and destructor functions.
+",Specification,
+SRS23,"SRS 23 - Libwarc shall use dynamic heap memory for its internal usage.
+",Specification,
+SRS24,"SRS 24 - Libwarc shall allocate minimum memory heap to store WARC-record metadata.
+",Specification,
+SRS25,"SRS 25 - The payload (or the WARC-record document itself) are stored on disk, to avoid using memory heap, even for small objects.
+",Specification,
+SRS26,"SRS 26 - Libwarc shall not use file to memory mapping technology, instead libwarc will explicitly allocate memory as needed.",Specification,
+SRS27,"SRS 27 - Libwarc shall support non-compressed WARC-records and compressed WARC-records and files
+",Specification,
+SRS28,"SRS 28 - The default compression format shall be Gzip
+",Specification,
+SRS29,"SRS 29 - Libwarc shall support multiple compression schemas, loading a specific compressor at runtime as an external shared library.",Specification,
+SRS30,SRS 30 - It shall not be possible to use more than one compression schema (including noncompression) within a single WARC file. (i.e. it is not possible to mix compression schemes within a single WARC file).,Specification,
+SRS31,SRS 31 - A command line tool shall be implemented utilising libwarc to check the consistency of WARC-records and their conformance to the WARC ISO standard.,Specification,
+SRS32,"SRS 32 - The command line tool shall notify the user of any WARC-record's anomalies, missing required fields or incompatible fields types.",Specification,
+SRS33,"SRS 33 - Libwarc shall provide a set of classes to enable remote management of WARC-records
+",Specification,
+SRS34,"SRS 34 - It shall be possible to perform read operations (read from offset, filters, etc.) on WARCrecords from a remote location via http.
+",Specification,
+SRS35,"SRS 35 - For security reasons, it shall not be possible to perform write or update operations on a WARC-record remotely
+",Specification,
+SRS36,SRS 36 - WARC browser shall not support CDX files because the CDX file format is not a standard at this time and is outside of scope.,Specification,
+SRS37,"SRS 37 - WARC Browser shall support a client-side rewriting interface by using javascript code to rewrite links being delivered alongside archived content. This is based on the principles implemented in the Wayback Machine.
+",Specification,
+SRS38,SRS 38 -A web proxy interface shall be implemented that allows the user to set their web browser proxy to the one provided by the interface and thereby ensure all content is delivered from the archive and not from the live web.,Specification,
+SRS39,"SRS 39 - Libwarc shall be incorporated within an Apache module to enable all actions specified in SRS 34-36 to be executed within Apache.
+",Specification,
+SRS40,SRS 40 - Libwarc shall be incorporated within a Lighttp module to enable all actions specified in SRS 34-36 to be executed within lighttp.,Specification,
+SRS41,"SRS 41 - A command line tool ""arc2warc"" incorporating libwarc shall be able to migrate data in ARC-records to WARC-record format.
+",Specification,
+SRS42,"SRS 42 - The default operation of ""arc2warc"" shall carry out a one-to-one mapping of record fields, by converting each ARC-record to a corresponding ""response"" WARC-record and ""metadata"" WARCrecord, which shall include information about the conversion process.
+",Specification,
+SRS43,"SRS 43 - ""arc2warc"" shall have make a default operation in cases where an ARC-record has no corresponding field in the WARC-record.
+",Specification,
+SRS44,"SRS 44 - It shall be possible to specify non-default operations of ""arc2warc"" using a named configuration file, which will describe the desired ARC-record to WARC-record conversion.",Specification,
+SRS45,"SRS 45 - A set of command line tools incorporating libwarc shall perform migration of ""HTTrack"" archives to WARC-records.",Specification,
+SRS46,"SRS 46 - The HTTrack archive file format and link strategy may vary from version to version of HTTrack, therefore it shall be possible to adapt the migration scripts to deal with these changes.
+",Specification,
+SRS47,"SRS 47 - A set of command line tools incorporating libwarc shall perform migration of ""wget"" archives to WARC-records.
+",Specification,
+SRS48,"SRS 48 - A set of command line tools incorporating libwarc shall perform migration of ""curl"" archives to WARC-records.
+",Specification,
+SRS49,"SRS 49 - A set of command line tools and an API incorporating libwarc shall enable the collection of online documents, such as html and embedded files, etc., and write them to valid WARC- records.",Specification,
+SRS50,"SRS 50 - The command line tools and API in SRS 50 will not include any links extraction features.
+",Specification,
+SRS51,"SRS 51 - Python scripts shall be implemented incorporating libwarc, and making all of the functionality of libwarc and API available in Python.
+",Specification,
+SRS52,"SRS 52 - Extensions to ""HTTrack"", ""wget"" and ""curl"" incorporating libwarc shall be provided as patches to recent and specific versions of each tool, to enable users of the tool to access functionality of libwarc
+",Specification,
+SRS53,"SRS 53 - Helper documentation for libwarc functionality shall be made available within the ""HTTrack"", ""wget"" and ""curl"" commands.",Specification,
+SRS54,"SRS 54 - A magic number for WARC shall be created and incorporated in the ""file"" mime-type database, enabling the simple identification of WARC files via the Unix ""file"" command",Specification,
+SRS55,"SRS 55 - The WARC validator tool specified in SRS 31-32 shall be extended to optionally make use of the Jhove command line API to identify and validate WARC files, i.e. given a specific WARC file, this command shall be able to identify the file as a WARC file, validate the level of compliance with a given standard in terms of well-formedness and validity, and finally to characterise the file by extracting and displaying significant properties contained in the file.
+",Specification,
+SRS56,"SRS 56 - WarcMdoule and WarcHandler plugin modules shall be implemented for Jhove Plugin layer to enable identification and validation of WARC files.
+",Specification,
+SRS57,SRS 57 - WARC files in various test-states shall be provided that test the Jhove deliverables,Specification,
+SRS58,"SRS 58 - Void, duplicate of SRS 79
+",Specification,
+SRS59,"SRS 59 - Libwarc shall provide interfaces to SWIG wrappers to allow dynamic language bindings (Python, Ruby, Perl, Lua ...)
+",Specification,
+SRS60,SRS 60 - A Python interface to libwarc shall be implemented using the SWIG wrapper,Specification,
+SRS61,SRS 61 - A Java interface to libwarc shall be implemented using the SWIG wrapper and/or JNI,Specification,
+SRS62,"SRS 62 - An independent Java implementation of libwarc may be implemented subject to review of deliverables satisfying SRS 61
+",Specification,
+SRS63,"SRS 63 - Libwarc and the bindings to its functionality shall enable the use of libwarc's iterators described in SRS 16-20 to be used within various dynamic languages and in Java v1.4 and earlier, using metaphors and paradigms familiar to those languages.
+",Specification,
+SRS64,"SRS 64 - Libwarc and the bindings to its functionality shall enable the use of libwarc's iterators described in SRS 16-20 to be used within Java v1.5 and and later, using Java's new container iterators, such as ""for"" and ""foreach"".",Specification,
+SRS65,"SRS 65 - It shall be possible for libwarc to be able to handle WARC file of any size, with minimal memory usage.
+",Specification,
+SRS66,"SRS 66 - It shall be possible for libwarc to be able to read, write and update WARC files at high speed, i.e. the design should focus on minimum memory footprint and performance.
+",Specification,
+SRS67,"SRS 67 - Libwarc shall be implemented to WARC v0.17.
+",Specification,
+SRS68,"SRS 68 - Major revisions to the WARC ISO standard may lead to revisions of libwarc, but these revisions should be isolated and not affect any tools developed incorporating libwarc
+",Specification,
+SRS69,"SRS 69 - Libwarc shall be developed on GNU/Linux, Fedora 7
+",Specification,
+SRS70,"SRS 70 - Libwarc shall be shipped with a manual and build scripts
+",Specification,
+SRS71,"SRS 71 - Libwarc shall be shipped with installation guides for Fedora, Debian, FreeBSD, Mac OS X 10.5 and Windows XP.
+",Specification,
+SRS72,"SRS 72 - Libwarc shall be shipped with a developer guide and useful examples.
+",Specification,
+SRS73,"SRS 73 - Libwarc shall be shipped with a number of ready-to-use command lines, for example, warcdump (to dump the contents of a WARC file), w-filter, etc.",Specification,
+SRS74,"SRS 74 - Utility and application level functionality of WARC Tools shall be made available to end users as command line tools, extensions to existing tools, and simple web applications for accessing WARC content",Specification,
+SRS75,"SRS 75 - Communication and support shall be provided to the open source community. This support must be provided for at least term of the project.
+",Specification,
+SRS76,SRS 76 - Patches implemented for third party projects shall be contributed and distributed to the appropriate community,Specification,
+SRS77,"SRS 77 - The code and documentation of libwarc shall be licensed to the community using an IIPC approved license, such as Apache 2.0 or BSD licence
+",Specification,
+SRS78,"SRS 78 - Libwarc and associated tools shall be shipped with installers to ""mod_warc"" for Apache (v2.X) and Lighttpd (v1.4.X) servers",Specification,
+SRS79,"SRS 79 - Libwarc shall be implemented in C and shall conform to ANSI-C standard C99 revision.
+",Specification,
+SRS80,"SRS 80 - To ensure code portability on older computer architectures, Libwarc shall be compatible with any compiler conforming to the ANSI-C standard C89 revision.
+",Specification,
+SRS81,"SRS 81 - Command line tools incorporating libwarc shall be atomic - i.e. each tool performing a single function, performing it perfectly, and in the spirit of Unix command lines tools. These may be combined using pipes and redirection and scripting, to create more high level commands.
+",Specification,
+SRS82,"SRS 82 - Libwarc source code shall be released in the following archives: ""libwarc-version.tar.gz"", ""libwarc-version.tar.bz2"", ""libwarc-version.zip"" together with their corresponding digests. Developers may then adapt the build configuration files for best performance on their target machines.",Specification,
+SRS83,"SRS 83 - Libwarc binary modules, ready to use binary commands and libraries (both static and shared), compiled with generic optimisation flags, shall be released also
+",Specification,
+SRS84,"SRS 84 - Libwarc shall be made available as a binary for at least GNU/Linux, FreeBSD, Mac OS X and Windows XP.
+",Specification,
+SRS85,"SRS 85 - Libwarc shall compile and run under Solaris, AIX, MingW or other Unix compliant system and may compile and run under Windows XP.
+",Specification,
+SRS86,"SRS 86 - Libwarc shall not depend on a specific build tool in order to be built from source. However, makefiles for each target shall be included to simplify deployment.
+",Specification,
+SRS87,"SRS 87 - The default compiler used for all Unix systems to build libwarc will be gcc v.3.4.4 (or above). For Windows, the default compiler will be Microsoft Visual C++ 6.X (or above).
+",Specification,
+SRS88,"SRS 88 - Only essential external libraries shall be used in libwarc, such as Gzip compression and wide characters encoding libraries.
+",Specification,
+SRS89,"SRS 89 - Assembly code and specific system features shall not be used in libwarc to ensure resulting code is widely portable across multiple target architectures
+",Specification,
+NFR01,"NFR 1 - The core functionality of WARC Tools, specifically the WARC writer/reader, shall be implemented as a comprehensive, standalone, general purpose software library - libwarc.",Non-Functional Requirement,
+NFR02,NFR 2 - WARC v0.17 shall be the baseline version of the WARC standard used in this project.,Non-Functional Requirement,
+NFR03,"NFR 3 - WARC Tools shall be highly portable, running on a range of Linux/Unix platforms and XP as a minimum, together with man pages, build and installation guides, developer guides, etc.",Non-Functional Requirement,
+NFR04,"NFR 4 - Utility and application level functionality of WARC Tools shall be made available to end users as command line tools, extensions to existing tools, and simple web applications for accessing WARC content.
+",Non-Functional Requirement,
+NFR05,NFR 5 - Communication and support shall be provided to the open source community. This support must be provided for at least term of the project.,Non-Functional Requirement,
+NFR06,"NFR 6 - The library and each tool or extension shall be documented for developers and end users, using man pages and other common document forms.",Non-Functional Requirement,
+NFR07,"NFR 7 - Patches implemented for third party projects shall be documented for developers and end users, using man pages and other common document forms.",Non-Functional Requirement,
+NFR08,NFR 8 - Patches implemented for third party projects shall be contributed and distributed to the appropriate community.,Non-Functional Requirement,
+NFR09,NFR 9 - The code and documentation shall be licensed using an open source license.,Non-Functional Requirement,
+NFR10,"NFR 10 - Installation scripts and/or instructions shall be made for the library and tools for each target platform, including Linux, Unix and Windows, as well as apache and lighttp installation scripts",Non-Functional Requirement,
+NFR11,NFR 11 - The WARC Tools shall be implemented as a C library,Non-Functional Requirement,
+NFR12,NFR 12 - Library functionality shall have APIs and dynamic language bindings to be made available as software libraries for developers.,Non-Functional Requirement,
+NFR13,NFR 13 - The functionality of the API shall enable the appropriate functionality in the library scriptable1 and programmable2.,Non-Functional Requirement,
+NFR14,"NFR 14 - Web server plug-ins shall conform to the Apache 'mod' API and shall operate correctly with both Apache and Lighttp servers and shall be compatible with appropriate web sever programming standards, such as WSGI in Python and the Servlet API in Java.
+",Non-Functional Requirement,
+NFR15,"NFR 15 - The deliverables shall be made available in source code, named as ""libwarc-version.tar.gz"", where version is the version of the library. A number of binary distributions may be made, including RPM, DEB and EXE.",Non-Functional Requirement,
+NFR16,"NFR 16 - The deliverables shall be ported to the following platforms: Linux, FreeBSD, Mac OS X 10.5 and Windows.",Non-Functional Requirement,
+NFR17,NFR 17 - The final WARC API shall be coded in C with minimum dependencies or external libraries (e.g. GZIP). It must not include any assembly code.,Non-Functional Requirement,
+NFR18,"NFR 18 - The C library will be developed in such a way as to allow it to be used with the Simplified Wrapper and Interface Generator, or SWIG, (www.swig.org) in order to wrap the C code and allow it to be called natively in a wide variety of languages.",Non-Functional Requirement,
+NFR19,NFR 19 - An interface implementation may be made for Python to allow the library to be used natively by Python programmers requiring no knowledge of the internal implementation of libwarc or C.,Non-Functional Requirement,
+NFR20,NFR 20 - An interface implementation shall be made for Java to allow the library to be used natively by Java programmers requiring no knowledge of the internal implementation of libwarc or C.,Non-Functional Requirement,
+NFR21,"NFR 21 - The functionality of the library shall be exposed in such a way as to fit the metaphors and paradigms of the specific implementation languages (C, Java, Python).",Non-Functional Requirement,

matrices.csv

@@ -0,0 +1,3 @@
+source_type,target_type
+Specification,Functional Requirement
+Non-Functional Requirement,Specification

traces.csv

@@ -0,0 +1,137 @@
+s_id,t_id,label
+SRS61,FR40,1
+SRS49,FR30,1
+SRS48,FR29,1
+SRS60,FR39,1
+SRS62,FR41,1
+SRS63,FR42,1
+SRS64,FR42,1
+SRS59,FR38,1
+SRS16,FR08,1
+SRS16,FR09,1
+SRS02,FR01,1
+SRS03,FR01,1
+SRS17,FR10,1
+SRS01,FR01,1
+SRS15,FR07,1
+SRS29,FR18,1
+SRS28,FR17,1
+SRS14,FR05,1
+SRS14,FR06,1
+SRS38,FR23,1
+SRS04,FR02,1
+SRS04,FR01,1
+SRS10,FR04,1
+SRS11,FR05,1
+SRS11,FR06,1
+SRS11,FR02,1
+SRS05,FR02,1
+SRS05,FR01,1
+SRS39,FR24,1
+SRS07,FR03,1
+SRS07,FR01,1
+SRS06,FR02,1
+SRS12,FR06,1
+SRS37,FR22,1
+SRS23,FR16,1
+SRS23,FR14,1
+SRS22,FR16,1
+SRS22,FR14,1
+SRS36,FR21,1
+SRS20,FR13,1
+SRS34,FR21,1
+SRS08,FR04,1
+SRS09,FR04,1
+SRS21,FR16,1
+SRS21,FR02,1
+SRS21,FR14,1
+SRS19,FR11,1
+SRS19,FR12,1
+SRS25,FR16,1
+SRS25,FR15,1
+SRS25,FR14,1
+SRS31,FR20,1
+SRS30,FR18,1
+SRS24,FR16,1
+SRS24,FR14,1
+SRS18,FR09,1
+SRS32,FR20,1
+SRS26,FR16,1
+SRS26,FR14,1
+SRS27,FR17,1
+SRS54,FR34,1
+SRS40,FR24,1
+SRS68,FR02,1
+SRS41,FR25,1
+SRS55,FR35,1
+SRS43,FR25,1
+SRS57,FR37,1
+SRS56,FR36,1
+SRS56,FR35,1
+SRS42,FR25,1
+SRS46,FR27,1
+SRS52,FR32,1
+SRS53,FR33,1
+SRS47,FR28,1
+SRS51,FR39,1
+SRS51,FR31,1
+SRS45,FR27,1
+SRS44,FR26,1
+NFR06,SRS72,1
+NFR06,SRS70,1
+NFR06,SRS71,1
+NFR12,SRS60,1
+NFR12,SRS63,1
+NFR12,SRS59,1
+NFR12,SRS51,1
+NFR11,SRS80,1
+NFR11,SRS79,1
+NFR05,SRS75,1
+NFR04,SRS49,1
+NFR04,SRS48,1
+NFR04,SRS74,1
+NFR04,SRS73,1
+NFR04,SRS31,1
+NFR04,SRS41,1
+NFR04,SRS52,1
+NFR04,SRS47,1
+NFR04,SRS45,1
+NFR10,SRS70,1
+NFR10,SRS78,1
+NFR14,SRS39,1
+NFR14,SRS40,1
+NFR01,SRS49,1
+NFR15,SRS83,1
+NFR15,SRS82,1
+NFR15,SRS84,1
+NFR03,SRS89,1
+NFR03,SRS72,1
+NFR03,SRS70,1
+NFR03,SRS71,1
+NFR03,SRS69,1
+NFR03,SRS80,1
+NFR03,SRS85,1
+NFR03,SRS84,1
+NFR17,SRS89,1
+NFR17,SRS88,1
+NFR17,SRS80,1
+NFR16,SRS85,1
+NFR16,SRS84,1
+NFR02,SRS67,1
+NFR18,SRS59,1
+NFR19,SRS60,1
+NFR19,SRS59,1
+NFR19,SRS51,1
+NFR09,SRS77,1
+NFR21,SRS61,1
+NFR21,SRS60,1
+NFR21,SRS62,1
+NFR21,SRS63,1
+NFR21,SRS64,1
+NFR21,SRS59,1
+NFR21,SRS51,1
+NFR20,SRS61,1
+NFR20,SRS62,1
+NFR20,SRS63,1
+NFR20,SRS64,1
+NFR08,SRS76,1