dataesr/scientific-paragraphs-categorization huggingface dataset:
ACKNOWLEDGEMENTS Bernard Séret (IRD-MNHN) kindly examined a fish specimen and prepared it for deposition in the MNHN collections, and provided valuable advice. Eileen Harris  ( NHM, London ) kindly helped with NHM specimens. Wiem Boussellaa  ( FSS, Tunisia ) provided a fish specimen. Delane Kritsky  ( Idaho State University, USA ) kindly authorised us to use data from a paper when it was in press. Tissue samples from Gulf of Mexico groupers were collected by fisheries biologists of the  Florida Fish and Wildlife Conservation Commission (FWC) , and of them we are particularly grateful to  Lew Bullock  and  Chris Bradshaw. Samantha Gray  (FWC) initially processed and catalogued Florida tissue samples and data. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the opinions or policies of the US government or any of its agencies.
The native app development is increased in Android systems to implement CPU-intensive applications such as game engines, signal processing, and physics simulation. However, native code analysis is very difficult and requires a lot of time which explains the limited number of systems that track information flow in native libraries. But, none of them detects the sensitive information leakage through control flows at native level. In this paper, we combine dynamic and static taint analysis to propagate taint along control dependencies. Our approach has proven to be effective in analyzing several malicious Android applications that invoke native librairies with reasonable performance overheads.
Period Percentage of apps using native libraries May-Jun 2011 4. 2%  (Zhou et al. , 2012)  Sep-Oct 2011 9. 42%  (Grace et al. , 2012)  Jun 2012-Jun 2013 16. 46%  (Qian et al. , 2014)  July 2013-Dec 2013 24%  (Spreitzenbarth et al. , 2013)  the increase in the number of Android apps employing native libraries from 4. 2% in 2011 to 24% in 2013. These applications can invoke System. load() or System. loadLibrary() to load native libraries such as game, music and audio and communication apps, or can contain native libraries without calling these methods or can be written in pure native code. Note that the restricted number of applications in pure native code is due to the limitations of the NDK (Native Developpement Kit) APIs. The native libraries can contain sensitive data such as phone identity, user contacts, pictures and locations.
An attacker can exploit this native code to get private information. Dynamic taint analysis can be used for checking information flows through JNI  (Java Native Interface)  and to control the handling of private data in Android systems  (Qian et al. , 2014). This technique assigns taint to sensitive data. Then, it tracks propagation of tainted data to detect leakage of private information by malicious applications. This, can be detected when sensitive data are used in a taint sink (network interface). Two types of flows are defined: explicit flows such as x = y, where we observe an explicit transfer of a value from x to y, and control flows shown in Listing 1 that occur in the control flow structure of the program. In this example, the attacker tries to get the user location by exploiting control flows.
The value of the variable x depends on the condition and it informs the attacker about the value of user location. When the test was positive, x is modified and it is leaked to the network without being detected because the dynamic taint analysis approach implemented in the Android native code does not propagate taint along control dependencies. Thus, malicious applications can get privacy sensitive data through control flows in native code. Our objective is to detect private information leakage by untrusted smartphone applications exploiting control flows in native code. In this context, many challenges need to be addressed: • The resource constrained nature of Smartphones: the limited processing and memory capacity of smartphones make it difficult to use information flow tracking systems  (Yin et al.
, 2007) ,  (Clause et al. , 2007) ,  (Kang et al. , 2011) ,  (Song et al. , 2008). Thus, it is necessary to design a resource efficient security mechanism. • The unavailable application source code: the source code of smartphone applications is often unavailable. • False negatives: while the most used information flow tracking systems  (Enck et al. , 2010) ,  (Hornyack et al. , 2011) ,  (Qian et al. , 2014) ,  (Yan and Yin, 2012)  do not track control flows, false negatives could occur and cause security flaws. The approach cited in  (Graa et al. , 2014)  proposed an enhancement of dynamic taint analysis that propagates taint along control dependencies in Java Android applications' code. In this paper, we improve this approach by considering also the native code and combining dynamic taint analysis and static analysis to control the manipulation of private data by thirdparty apps that exploit control flows in native libraries to leak sensitive information.
To the best of our knowledge, this is the first paper that tracks control flows in native Android code to detect the leakage of private data. Analysis of applications' behavior at native level is very difficult and requires a lot of time. To be practical, the performance overhead of our system runtime must be reasonable. In addition, sufficient contextual information about propagation of private data in Java and native levels is needed. Thus, we use the data tainting technique and we assign taint to sensitive information. Also, it is not trivial to track control flow in native code. So, we use static analysis to detect control dependencies. This paper is organized as follows: section 2 defines the problem statement. Related works about existing systems that consider native libraries invoked by Android applications and existing approaches that detect control flows are discussed in section 3.
PROBLEM STATEMENT We present in this section the problem that our approach solves. The under-tainting problem occurs when some values should be marked as tainted, but are not. The dynamic taint analysis approaches implemented in Android native code do not propagate taint in control flows which can cause an under-tainting problem. Consider the example in Listing 3 that presents an under tainting problem in Android native code. The malicious program written in Java code (see Listing 2) gets the device id and passes it as argument to a native function (written in C). In the native code presented in Listing 3, the attacker compares each character of private data with symbols in AsciiTable (TabAsc). Then, he stores the sequence of characters found in the string Z. The variable Z contains the value of the private data but it is not tainted using existing dynamic analysis taint systems.
S t r i n g P r i v a t e D a t a ; S t r i n g Z ; s t r c p y ( P r i v a t e D a t a , IMEI ) ; f o r ( i n t i = 0 ; i < s i z e o f ( P r i v a t e D a t a ) ; i ++) { c h a r s ; s p r i n t f ( s , "%d " , i ) ; f o r ( i n t j = 1 ; j < s i z e o f ( TabAsc ) ; j ++) i f ( s t r c m p ( s , TabAsc The taint sink can be defined in the Java code. In this case, another Java program searches the sensitive information from the native code, or the native method calls and passes the sensitive information to Java code. Then, the Java code leaks the private data. As it is not tainted, it will be sent without any warning reports. As the dynamic taint analysis approaches cannot detect a leakage of sensitive information caused by the under-tainting problem. We aim to enhance these approaches by tracking control flow in the Android native code.
This, does not reflect the exact taint propagation in native code, because it under-taints explicit information flows from native code to Dalvik virtual machine (DVM). AppFence  (Hornyack et al. , 2011)  extends Taintdroid to implement policy enforcement. A significant limitation of these dynamic taint analysis approaches implemented in Android systems is that they track only explicit flows in Java code level and they do not consider native libraries. Native Libraries Approaches. Fedler et al. (Fedler et al. , 2013)  assert that all current local root exploits are exclusively implemented as native code and can be dynamically downloaded and runned by any app. Since, the lack of control mechanisms for the execution of native code poses a major threat to the security of Android devices,  Fedler et al.
propose mechanisms to control native code execution. Some works have been undertaken to consider native libraries in Android applications. DroidRanger  (Zhou et al. , 2012)  records any calls to the Android framework APIs for the dynamically loaded Java code and their arguments to provide rich semantic information about an app's behavior. For the dynamically-loaded native code, it collects system calls made by the native code using a kernel module that catches the system calls table in the (Linux) kernel. RiskRanker  (Grace et al. , 2012)  compares native code of apps with the signatures of known root exploits. To analyze potential harmful applications for the Android platform, AASandbox  (Blasing et al. , 2010)  realizes system and library call monitoring. Paranoid  (Portokalidis et al. , 2010)  and Crowdroid  (Burguera et al.
, 2011)  intercept system calls and signals of processes. The dynamic analyzer presented in  (Spreitzenbarth et al. , 2013)  traces code included in native shared objects, those included with the app through the NDK as well as those shipped with Android by intercepting library calls of a monitored application. CopperDroid  (Reina et al. , 2013)  instruments the Android emulator to enable system call tracking and support an out-of-the-box system call-centric analysis. DroidScope  (Yan and Yin, 2012) , an emulation-based Android malware analysis engine, used to analyze the Java and native components of Android Applications. It implements several analysis tools to collect detailed native and Dalvik instruction traces, profile API-level activity, and track information leakage through both the Java and native components using taint analysis.
One of the limits of DroidScope is that it incurs high overhead. DROIT (WANG and SHIEH, 2015)  is an emulation-based taint tracking system. It tracks data flow at Java object level and switches to instruction level instrumentation when native code starts to take over. DROIT is designed to profile the program behavior. So the program is considered as the taint source. On the contrary, in TaintDroid the data in the program presents the taint sources. NDroid  (Qian et al. , 2014)  extends TaintDroid to track explicit flow in native code. The major disadvantage of all approaches that consider native libraries is that they do not propagate taint in control flows. Control Flows Approaches. Cavallaro et al. (Cavallaro et al. , 2008)  describe the evasion techniques that can easily defeat dynamic information flow analysis using control dependencies.
Components colored in gray (see Figure  1 ) present the Java Taint Instruction Tracer module of this approach  (Graa et al. , 2014) ,  (Graa et al. , 2012)  implemented in the Dalvik VM for tracking information flows at Java level. Authors modify the Dex verifier to statically analyze the Java Android app's code and the interpreter for the dynamic analysis. The Java taint sink is defined by instrumenting the Java framework libraries. For more implementation details of the Java Taint Instruction Tracer module, please refer to  (Graa et al. , 2012) ,  (Graa et al. , 2014). For JNI methods, authors patched the call bridge to provide taint propagation. In addition, they defined a method profile that is a list of (from; to) pairs indicating flows between variables for tag propagation in JNI methods.
It will be used to update taints when a JNI method returns. Authors add an additional propagation heuristic patch that assigns taint to the returned value of a JNI function if one parameter is tainted. This, does not reflect the exact taint propagation in native libraries. Thus, to ensure the proper propagation of the native code, we implement the Native Taint Instruction Tracer module (see Figure  1 ) that instruments the AR-M/Thumb instructions. Also, we use static analysis to enumerate the information flows (control flows) for all JNI methods. In addition, when a native function is invoked in  (Graa et al. , 2014) , the corresponding taint is not stored in the native runtime stack. So, they do not get and set taints correctly when the context (Java and native) switches. Therefore, we define the Context Switching Functions module (see Figure  1 ).
HANDLING CONTROL FLOW IN NATIVE LIBRAIRIES The architecture of our approach is presented in Figure 1. The Android system runs on top of an emulator QEMU (Wiki, 2015) which provides information about all generated ARM/Thumb Android instructions. Thus, we made a number of modifications to QEMU to implement our proposed approach. We define four modules: (1) Native Taint Instruction Tracer module that handles explicit and control flows at native level; (2) Context Switching Functions module; (3) Native Taint sink module and (4) Information Kernel module.
Native Taint Instruction Tracer The Native Taint Instruction Tracer module is composed of (1) Explicit flow component that tracks direct flows and (2) Control flow component that tracks indirect flows at native level. We instrument the ARM/Thumb instructions of native libraries invoked by Android applications to propagate taint in explicit flow. We handle unary, binary, move operations. For these operations, we add taint propagation instructions that assign to the destination register (R d ) the combination of all taints of source registers (R n , R m ). We propagate taint tags in explicit flow referencing data flow rules presented in Table  2. #imm represents the immediate number with a null value of taint. The t(M[addr]) is the taint of memory at address addr that is calculated using R n and #imm (Cal(R n , #imm)).
Context Switching Functions When the context switches from Java to native, we store the taint in native runtime stack for tracking information flow at native level. The Context Switching Functions module instruments JNI-related functions that ensure switching between the two contexts. These functions allow Java code to invoke native code. We hook the JNI call bridge (dvm-CallJNIMethod) to detect native invoked methods. Then, we assign to each invoked native method a SourcePolicy structure where arguments taints of this method are stored. Finally, we add taints to the corresponding native context registers and memories. Moreover, these functions allow native code to call Java methods through the dvmCallMethod function. We save taints in shadow registers and memory at native level and we use them to set taints in the Dalvik virtual machine stack when native codes invoke Java codes by instrumenting the dvmInterpret method.
Information Kernel The Information Kernel module provides Android Linux kernel information of processes and memory maps. We use the virtual machine introspection  [16, 21, 24]  technique described in Droidscope for reconstructing the OS-level view. The QEMU emulator disassembles and translates a basic block of guest instructions into an intermediate representation called TCG (Tiny Code Generator). Then, it compiles the TCG code block down to a block of host instructions and stores it in a code cache. To extract OSlevel information (running processes, and the memory map) we instrument translated code blocks and we add TCG instructions at the code translation phase.
Effectiveness We download and analyse 40 free frequently used Android applications from the Google Play store (see Table  3 ). These applications access and handle private data such as location, contacts, phone state, camera and SMS. As shown in Table  3 , 16 applications (marked with *) invoke native libraries. We use dex2jar tool  (Google, 2015)  to translate dex files of different applications to jar files. Then, we use jd-gui  (Java, 2015)  to obtain the Java source code that will be analysed. For native code, we disassemble the libraries object code and we get the assembler mnemonics for the machine instructions by executing objdump (part of the GNU Binutils) (sourceware, 2015). We found that 23 Android applications (see Table  4 ) leak private data through information flows: • Six applications use explicit flow in Java context and cause the leakage of sensitive information like location, phone state, contact and camera.
Performance To evaluate the performance of our approach, we study our static and dynamic analysis overhead. We perform the static analysis at load and verification time. Our approach adds 37%, and 30% overhead with respect to the unmodified system respectively at load and verification time. This, is due to the verification of method instructions and the construction of the control flow graphs used to detect the control flows. We use CF-Bench  (Bench, 2011)  which is a CPU and memory benchmark tool to study our taint tracking approach overhead. We choose CF-Bench because it produces a fairly stable score, and tests both native as well managed code performance. As shown in Figure  2 , our approach incurs in average a slowdown of 14. 9 times. This time of overhead is greater than the result of NDroid (5.
Methods We collected and collated data and information from a search of published and unpublished secondary sources, in French and English, conducted in August to October 2015 using the open source catalogues of Google Scholar and Scopus: Key search terms ("forest conservation", "ecosystem services", "sustainable development", "forest cover") were used in a boolean combination with the key terms "global", "Madagascar", and "tropical". We also used our own sources on Madagascar's biodiversity based on the Noe4D database  [15]  comprising ca. 10,000 references and 50,000 georeferenced records primarily documenting the endemic vertebrate fauna. Noe4D was also consulted to assess research efforts driven by Malagasy institutions and individuals (cf. S1   and c ) aid funding provided by bi-and multi-lateral donors to the Malagasy Government to support the implementation of these projects.
The IUCN Red List highlights species whose evaluation shows they are at the greatest risk of extinction, providing a valuable tool for conservation  [33, 34]. Starting in the early 1990s, assessments of species submitted to the IUCN Red List require "p. 72. the rationale for listing, supported by data on range size, population size and trend, distribution, habitat preferences, altitude, threats and conservation actions in place or needed"  [34]. Examples of global assessment are provided by  Butchart et al. in 2004 [35]  for birds and Nori & Loyola in 2015  [36]  for amphibians, and Brummitt et al. [37]  examined a sample of plants, all with the goal of facilitating the integration of information on threatened species in the design of protected areas. For Madagascar, 3921 native taxa have been assessed, including 1036 plants (representing no more than 8% of the 12,000-14,000 plant species in Madagascar) and 2885 animals (2077 vertebrates, including 268 amphibians, 392 reptiles, 244 birds and 245 mammals; cf.
Fig). Publicly available databases and annual reports of the International Union for Conservation of Nature (IUCN), World Bank, United Nations Development Program (UNDP), Organization for Economic Co-operation and Development (OECD), and Food and Agricultural Organization (FAO) were consulted to access data and information relating to: a) indicators of the Millennium Development Goals (MDGs) (cf. Tables A-S in S1 File), b) institutions involved in Madagascar's conservation and development projects (the operators),.
No significant difference was found between different curvature magnitudes (Figure  S1 , Supporting Information). v = ± -) (Figure These results are in agreement with a study of Park et al. , who showed that mouse fibroblasts move significantly faster in concave pits with a diameter of 200 µm and a depth of 50 µm compared to flat surfaces. [11] In further agreement with our findings, cell speed on convex posts was not significantly different from flat surfaces. In the mentioned study however, both the time lapse experiments and the immunohistological data were recorded as 2D images. Therefore, information about the details of cell movement and attachment was missing. In our study, z-stack time lapse recordings of migrating cells provided 3D information on the cellular attachment-morphology during migration on the differently curved surfaces.
Experimental Section Design and Production of the Cell Culture Chip: Cell culture chips containing 3D structures were designed using computer-aided design software (Rhinoceros 3D, McNeel Europe). The chips contained convex and concave spherical structures with principal curvatures of κ = 1/125, 1/175, 1/250, and 1/375 µm -1. Correct distance to the inverted microscope lens was ensured by 500 µm high feet at each Figure  6. Schematic representation of the proposed geometry-induced changes in cellular attachment and forces on the nucleus for flat, concave and convex surfaces. Nuclei are depicted in blue, F-actin in red and focal adhesions in green. In cells on concave surfaces, cytoskeletal forces result in an upward pull force away from the substrate. The cell body is lifted away from the surface and remains attached only at distinct adhesion points while the nucleus is not exposed to severe cytoskeletal forces.
Laser power and detector settings were kept constant during the imaging of the different probes. Cell Speed Analysis: Acquired time-lapse images of the migration assay were analyzed using ImageJ plugin MtrackJ. [40] The centers of in total 517 cells (164 cells on concave, 181 cells on convex, and 172 cells on flat surfaces) were tracked manually. The migration speed at each timeframe was calculated as the scalar of the displacement vector between two images, divided by the timeframe interval. Data from cells located at a z-position within a range of 50 µm from the flat surface were excluded from further analysis. This criterion was chosen to analyze only cell movement on the structures and not on the surrounding flat surface or on the transition region from flat to curved surface. The average migration speed of every tracked cell on the structures was calculated.
Data Analysis of Immunohistochemistry Data: Images were analyzed using custom-made macros in ImageJ to ensure a consistent analysis. For osteocalcin, F-actin, and lamin-A, z-stack images were summed and plotted. Regions of interest were selected to exclude artefacts and information from surrounding flat surface (for convex/concave structures). Background fluorescence from the chip was subtracted. The average signal intensity per cell was calculated by multiplying the pixel intensity values with the number of pixels that contain this intensity, divided by the total cell number. For the vinculin images, the background was subtracted, images were binarized, and the number and areas of the focal adhesions were analyzed. Focal adhesions close to the nucleus (Figure  3C ) were analyzed in a circular area of 405 µm 2 around the center of the nucleus.
(2012)  under controlled laboratory conditions. We modeled their results on minimum generation time at different temperatures with a nonlin-ear regression model based on the least squares method and a Gaussian curve, which visually fit the data point provided by Kakaire et al. (Fig. S1 ), using the software R (R Core Team 2014, version 2. 12. 2). This model was then used along with monthly temperature data provided by two weather stations (M et eo-France data), one located near Granville and Saint L eonard, and the other one located near Montfarville, to estimate the maximum number of generations produced by H. schachtii between the two sampling sessions. In subsequent analyses, we used these minimum and maximum numbers of generations as well as their median value to evaluate the impact of this demographic parameter on effective population size estimations.