dataesr/scientific-paragraphs-categorization huggingface dataset:
g. , blocks I, J, K, and L); two adjacent blocks, if each is compressible to 32 bytes (e. g. , blocks S and T); and only one block, if it is not compressible (e. g. , block Y). By allowing variable-size compressed blocks-16, 32, and (uncompressed) 64 bytes-SCC is able to tightly compact blocks and achieve high compression effectiveness. Figure  2 (a) shows one set of an SCC tag array and its corresponding dataset for a fourway associative cache. Like a regular cache, SCC has the same number of tags as data entries (e. g. , four tags and four data entries per set). However, as shown in Figure  2 (a), each tag entry includes the super-block tag address and per-block coherency/valid states. For this example, compared to a regular cache, each super-block tag entry only requires an additional 7 bits of storage: 9 additional coherency/valid bits for the three additional blocks but 2 fewer tag address bits, as each tag maps a 256-byte (four-block) super-block.
YACC Architecture Figure  3 (a) shows a high-level overview of an eight-way associative YACC design. Like SCC, YACC uses sparse super-block tags to exploit both spatial locality (i. e. , there are many neighboring blocks in the cache) and compression locality (i. e. , neighboring blocks tend to have similar compressibility). YACC stores neighboring blocks in one data entry if they have similar compressibility and could fit in one data entry. Figure  3 (b) shows how YACC partitions the address. For the sake of simplicity, throughout this article, the (uncompressed) data block size is 64 bytes and superblocks have four blocks. Thus, the lowest 6 bits in the address (bits A 5 -A 0 , labeled Byte in Figure  3(b) ) refer to the byte offset in a block. The next 2 address bits (bits A 7 -A 6 , labeled Blk ID in Figure  3(b) ) identify which block is accessed in a super-block.
Unlike SCC's skewed-associative design, YACC keeps the tag-data mapping simple by using a simple bit-selection hash function to select a conventional set. Figure  3(b)  illustrates that YACC uses the bits just above the block ID to index both the tag and data arrays. Cache hits are detected by comparing the super-block tag and checking the corresponding block's 3-bit coherence/valid state. YACC eliminates the implementation issues that make DCC and SCC less than ideal designs. YACC uses a conventional super-block tag array and an unmodified data array. In contrast, DCC requires significant changes to both the tag array (to add back pointers as well as other state bits) and data array (to access sub-blocks). SCC requires changes to only the tag array but requires separate decoders to implement the different hash functions and add additional state bits.
YACC only requires the addition of a few state bits to the tag array, which is a relatively simple change. We will next discuss YACC design in more detail. 3. 1. 1 YACC Tag Format. Like SCC, YACC uses sparse super-block tags  [Sardashti et al. 2014]  to map the blocks that are compressed in the corresponding data. In Figure  3(a) , blocks E, F, G, and H of super-block SB2 are each compressible to one 16-byte sub-block and YACC stores all four in one 64-byte data entry. Thus, this implementation of YACC has the potential to increase the cache capacity by a factor of 4. Conversely, blocks M and P of super-block SB4 are each compressible only to 32-bytes, and blocks O and N are not compressible; therefore, SB4 requires three separate data entries to hold its blocks: one for blocks M and P and one each for blocks O and N.
Finally, Figure  3 (e) illustrates the case that the block is uncompressible, with CF1 = 0 and CF0 = 0. In this case, there is a single coherence state field and a single block index. Figure  3 (a) shows that the tags for blocks A or D use this format. 3. 1. 2 How to Allocate Compressed Blocks? Like SCC, YACC uses a direct tag-data mapping to keep compressed block allocation simple. It compresses blocks into a power of two numbers of sub-blocks (e. g. , one, two, or four 16-byte sub-blocks). It then stores blocks with the same compression factor in a single data entry if they fit (e. g. , blocks E, F, G, and H of SB2). Otherwise, YACC stores them in one or more other data entries in the same dataset. For example, blocks I, J, and L from SB3 are each compressible to half a block. YACC fits I and J in one data entry (way 3 of set 0) and stores L in a separate data entry in the same set (way 0 of set 0).
The main concern here is how to enforce jurisdictional regulations such as DPD  '25. 1 in mobile apps. As the first pace to tackle the problem, we design and implement PDTLoc (Personal Data Transfer Location Analyzer), which employs both static and dynamic analysis techniques to infer whether the apps violate DPD'25. 1. PDTLoc inspects mobile applications and extracts information about the collected personal data and the jurisdictions of the remote servers to which the data is transferred. In order to investigate the current state of the privacy protection of the European smartphone users with regard to DPD'25. 1, we used PDTLoc to analyze the 1, 498 most popular apps in the EEA. We obtained evidence confirming that 16. 5% (that is 242 apps), transfer data outside the EEA whitout user consent.
This signifies that these apps collect and transfer personal data to servers located outside the EEA escaping the control of a data protection framework (e. g. , Safe Harbor), thus violating the users' data protection rights. We also analyzed the privacy policies provided by the app developers. One striking finding is that 51% of the most used apps in Europe do not provide any privacy policy. Furthermore, out the apps providing a privacy policy, only 53 apps (3. 5% of all) have Safe Harbor certification, whose agreement was anyway declared invalid, as we mentioned above. Perhaps the situation will be clarified when the EU-US Privacy Shield framework will be finalized.
Contributions: -We design and implement PDTLoc, an Android app analysis tool that employs a backward program slicing technique to detect DPD'25. 1's violation by mobile apps  [34]. -We collect a dataset of 1, 498 Android apps which are the most used apps in the EEA. We analyze these apps using PDTLoc to investigate the recipient server locations of the users' personal data. To our knowledge, this is the first study of the kind conducted so far. -In order to demonstrate the gravity of the problem, we also analyze the privacy policies of the apps in the dataset in order to check if the data controller and the processing locations are clearly identified. Organization: Section 2 provides a formal description of the problem. Section 3 discusses the background of data flow analysis. We explain the design and implementation of PDTLoc in Section 4 and discuss the empirical analysis setup and the results in Section 5 and Section 6, respectively.
In the analysis we perform in this work, the major goal is to expose the status of privacy protection with respect to DPD'25. 1 by the most popular mobile apps in the EU. More specifically, we analyze the type of personal data accessed by these apps, the number of apps that collect/transfer personal data to servers over the network, and the locations of the recipient servers. Caveat: In this work, we do not try to assert the compliance of the apps but rather to detect if they are likely violating user's privacy rights concerning international data flows limited by the DPD'25. 1.
Overview Figure  1  shows an overview of the basic blocks and the workflow of PDTLoc. PDTLoc consists of three major modules: a static analysis, a dynamic analysis, and a location investigator module. Both the static and the dynamic analysis modules take an. apk file; extract a list of accessed personal data; and a list of server names, URLs and IP addresses to which the personal information is sent. The dynamic analysis module complements the static module and it is only activated when the given app uses reflection. The lists of URLs extracted by both the modules may wary due to different nature of these analysis techniques. Therefore, we consider a union set of both the lists. The lists of URLs along with the identifiers of the respective personal information, which is sent to these URLs, are stored in a repository for further analysis.
Static Analysis Module PDTLoc's static analysis module, represented by module 1 in Figure  1 , takes an. apk file and extracts the URLs/IP addresses of the destination servers. APK is an archive file format that represents the Android app and contains all the compiled code and the compiled/raw resources. Android apps are usually written in Java, compiled into Dalvik bytecode and then all the compiled classes are packed into a classes. dex file. Therefore, we have to analyze this file to understand the behavior of the app. To analyze the classes. dex file, the static analysis module extracts and translates it into Smali code by employing ApkTool  [39]. Smali code is a disassembled representation of the Dalvik bytecode  [22]. We use Smali disassembly over Java because the decompilation process is more prone to be thwarted by obfuscation, whereas the disassembly is more resilient  [37].
The Static Check component inspects the Smali code for the use of reflection in order to pass the app to the dynamic analysis module. The Backward Slicer performs backward program slicing on the Smali files to discover the information flow to certain sink APIs. This component employs an extension of SAAF (Static Android Analysis Framework for Android apps) that is able to extract the backward slices corresponding to a given sink API  [25]. Table  1  lists the sink APIs along with the corresponding parameters of interest used in our analysis. We carefully analyzed the lists of sink and source APIs provided in the literature, such as  [6, 42] , and considered only those sink APIs that take the name or IP address of a particular server and transfer data to it. The Backward Slicer receives these APIs in the form of an.
Similar slices representing each of the BT patterns are extracted in the form of BT report and provided to a Slice Analyzer. The Slice Analyzer component traverses the slices and extracts URLs/IP addresses to which user's personal data might be transferred. Its major role is to analyze the slices for certain data extraction patterns that represent access to personal data. A typical data extraction pattern consists of a class name, a method name, and a parameter as listed in Table  2. This list includes only the APIs provided by the framework, used to acquire a user's personal information. However, it does not consider other methods of acquiring user per-  sonal data, such as data input through text fields or that stored on files on the device, etc. At this stage, PDTLoc can only guarantee the existence of such data flow paths and flags them suspicious with respect to their potential violation of DPD'25.
Dynamic Analysis Module We dynamically analyze the apps using reflection (around 90% of the apps in this study) that can potentially conceal data flows when only statically analyzed  [45]. Therefore, based on the static checks, the PDTLoc's dynamic analysis module, (module 2 in Figure  1 ), is activated in case of the app making use of reflection. The dynamic analysis module utilizes a number of tools provided as part of the Android SDK. It executes the given app, monitors its network traffic, and captures the URLs/IP addresses to which the personal data is transferred. It employs adb to manage the dy-namic analysis process that follows certain steps for each app: -Launch the emulator and configure WiFi and GPS. -Run the TCP-Dump tool to monitor the network traffic  [38]. -Install the app and unlock the emulator.
Location Investigator The fundamental purpose of PDTLoc is to analyze an app and tell if it sends user's personal data to servers hosted at locations outside the jurisdiction defined by the given policies, e. g. , the EU DPD'25. 1. Therefore, we need to investigate the physical locations of the machines represented by the extracted URLs/IP addresses. The PDTLoc's third module is Location Investigator (module 3 in Figure  1 ). This module reads the URLs/IP addresses of the remote servers from the repository and determines their physical locations. There are a number of online databases that bind IP addresses (or server names) to their corresponding geographical locations. We configure the Location Investigator to use IPaddressAPI. com [28]. The Location Investigator retrieves the locations using this online IP-Location service and reports a mapping of URLs and geographical locations.
Dataset Collection Since this work considers the analysis of the transfer of European users' personal data outside the EEA as a case study (i. e. , violating DPD'25. 1), we have targeted the popular mobile apps in the EEA. For the app selection, we relied on AppFigures which is an app tracking platform that monitors the downloads and sales of the apps from Google and Apple app stores  [5]. We downloaded AppFigures's list of the 400 most popular apps for each EEA state. We identified 1, 498 distinct android apps for the entire EEA and downloaded them. We use android apps because they have over 80% of the market share  [27] , also for the availability of analysis tools and their simple downloading mechanism. However, we searched for the apps in our list, on iTunes in order to check their availability for iOS.
In the dataset we have collected, 80% of apps are available for both Android and iOS and 20% are available only for Android. Therefore, our research results are meaningful to iOS users as well; assuming the destination cloud servers are the same for both OS, which is reasonable. We developed a crawler to download. apk files. It browses the given marketplace website for the download link of each app and downloads it. Moreover, since some marketplaces do not provide the download link instantly, the crawler manages to switch to another marketplace to ensure that the app is downloaded. We submitted all the downloaded. apk files to VirusTotal which is an online service to analyze suspicious files and URLs  [41] ; it marked them as benign.
Experimental Setup As PDTLoc consists of a static and a dynamic analysis module, we designed the experiment in such a way to know the results from both modules separately as well as their combined results. The static module analyzes all the apps in the dataset, whereas the dynamic module analyzes those apps which pass the static reflection check. Static analysis module configuration: This module analyzes all 1, 498 downloaded. apk files. We used a desktop computer with an Intel Core i5 3. 20 GHz CPU and 8 GB memory running Ubuntu 15. 10 for the analysis. The static analysis took roughly 38 hours on this machine. Dynamic analysis module configuration: The dynamic module analyzes those apps that are marked for the use of reflection. We call it Auto-Dynamic as it uses Monkey to stimulate the apps.
Contacted Servers The static analysis and the dynamic analysis module extracted, in total, 135 K and 21 K valid URLs/IP addresses, respectively. The number of URLs extracted by the static analysis module is much more as compared to those extracted by the dynamic analysis. The disparity in these numbers further endorses that static analysis provides an over-approximation of the program and extracts URLs which might not be contacted in an actual program execution, whereas the dynamic analysis extracts only those URLs which are contacted by the app in a single run. However, the presence of any of these URLs in the executable of an app provides a potential data transfer point and cannot be ignored. Since the purpose of dynamic analysis is to widen the analysis range, we use a combination of the URLs/IP addresses extracted by both the modules.
Server Locations Figure  5  illustrates the distribution of locations for servers engaged in the transmission of personal data (RQ2). As it reveals, only 23% of the servers are hosted in the EEA and the majority of the servers (67%) is in the US. Therefore, it is expected that the major portion of personal data to travel outside the EEA. The main focus of this work is to provide a location analysis of the servers contacted by the apps in our dataset. Figure  6  shows a graphical representation of the country-wise distribution of servers based on the number of apps. It illustrates that a reasonable portion of the apps contact (observed and potential data transfer) servers outside the EEA and US, especially China, Japan, India and Russia. As most of the analyzed apps contact servers outside the EEA, it is interesting to know the number of apps transferring data only to a certain location/country.
Limitations PDTLoc determines the physical location of the remote servers by employing a third party service e. g. , IPAddressAPI. com; thus, it relies on the information provided by this service. Our server location analysis of the apps is based on the 1st hop server and do not consider if the personal data might be transferred to another server, e. g. , App1 transfers data to abc. com and then the data is transferred from abc. com to xyz. com. In this case, PDTLoc only considers the transfer of data to the 1st server. It is impossible to trace data transfer once they are released to a server without collaboration of the target server. However, the mere transfer of the data towards another jurisdiction without explicit consent by the data subject and for which no international agreements are in place, already represents a violation.
It uses a system dependence graph to perform taint analysis. Based on bytecode analysis of Android apps, DroidAlarm is a tool designed to counter privilege escalation by detecting capability leaks  [47]. It uses control flow graphs to detect and extract capability leak paths from to sensitive sources to public interfaces. However, it only supports Android 2. 2 which is quite outdated. AmanDroid is an inter component-data flow analysis framework for Android apps  [42]. It is an extensible tool implemented in Scala and based on an intermediate representation of Dalvik bytecode. Amandroid per-forms data flow analysis by constructing an inter component data flow analysis graph. It provides a plugin for taint analysis which captures data flow between various sources and sinks of information. The sources and sinks are easily configurable in Amandroid's taint analysis plugin.
Theoretically, these sort of tools are ideal for detecting privacy leakage. However, we practically tried it on some apps and it could not detect some very obvious data flows. Bodden et al. presents, Flowdroid, one of the most sophisticated static analysis tool for Androd  [6]. It is a Soot based tool which performs data flow analysis on a representation of Java bytecode called Jimple  [40]. They also publish a benchmark of applications, known as DroidBench, which can be used to test data flow analysis tools. Epicc is another static analysis tool which focuses on privacy leakage considering inter component communication and inter app data flows  [32]. They provide a cover for privacy leakage between various components of an app and among multiple apps, which most of the static analysis tools do not consider.
To make it a complete package, Didfail and IccTa are two other tools which combine Flowdroid and Epicc  [9]   [30]. They utilize the object/field/context sensitivity of Flowdroid and the inter-component data flow detection Epicc to construct superior tools. This chain of static analysis tools, however, is based on Soot that was designed for Java applications and some times fails to analyze Android apps. As a matter of fact, some of these static analysis tools capable of detecting privacy leakage can be adopted to be used in our work. However, we preferred performing analysis on Smali code as it provides a direct representation of the Dalvik bytecode. Therefore, we used an extension of SAAF that performs analysis on Smali code and is based on backward program slicing of apps. The extension of SAAF overcomes some of its limitations, such as handling data flow through intents.
However, such tools require a dynamic triggering solution to effectively execute portions of the code that leak private information. To counter this problem, some tools provide their own triggering solution along with privacy leakage detection, e. g. , AppsPlayground, AppIntent, etc. [33, 43]. However, most of these tools still suffer from code coverage issues and increasing the code coverage when analyzing Android apps is an open research problem. Moreover, Shauvik et al. performed an analysis based study of the state-of-the-art open sourced test input generation tools for Android applications  [12]. Surprisingly, random exploration strategies based tools performed far better than the other model based and systematic tools. Since even the more sophisticated tools do not yield considerable improvement in the code coverage and unnecessarily complicate the process, we use the standard application exerciser provided with the Android SDK,i.
The group contribution approach allows users to upload molecular information in the form of SMILES (Simplified Molecular Input Line Entry System) strings and UManSysProp will automatically extract the relevant information for calculations. Built using open-source chemical informatics, and hosted at the University of Manchester, the facilities are provided via a browser and device-friendly web interface, or can be accessed using the user's own code via a JSON API (application program interface). We also provide the source code for all predictive techniques provided on the site, covered by the GNU GPL (General Public License) license to encourage devel-opment of a user community. We have released this via a Github repository (doi:10. 5281/zenodo. 45143). In this paper we demonstrate its use with specific examples that can be simulated using the web-browser interface.
epa. gov/tsca-screening-tools/ download-epi-suitetm-estimation-program-interface-v411). This provides a number of facilities including estimates of physical/chemical properties (melting point, water solubility, etc. ) and environmental fate properties (breakdown in water or air, etc. ). The Dortmund Databank (DDB) provides a wide range of database and software products related to fundamental properties of molecules and mixtures. With varying proprietary and free educational access, their program package ARTIST -Thermophysical Properties from Molecular Structure was developed for the estimation of pure component properties from molecular structure. In the UK the National Chemical Database Service (CDS) provides free access to web-based services including ACD (Advanced Chemistry Development Inc.
Relevant inputs to replicate these examples are given in the text, with larger files to upload provided in Appendix A. If you want to access UMansSysProp without using a web-browser, we also provide a programmer friendly JSON API (application program interface) that enables you to call our suite of tools from your own code. This is described in detail on our ReadTheDocs. org web page (https://umansysprop. readthedocs. org/) with an example provided in Appendix A. We also provide the source code for all predictive techniques provided on the site, covered by the GNU GPL (General Public License) license to encourage development of a user community. We have released this via a Github repository https://github. com/loftytopping/ UManSysProp_public. git, which has an associated DOI for the exact model version given in this paper as provided by the Zenodo service (doi:10.