dataesr/scientific-paragraphs-categorization huggingface dataset:
blender. org; Fig. 2G ; see Supplementary Blender file "Template 3D Heatmap"). Step-by-step guidelines for installation and optimal use of "FlashMap". While installing the software (see Supplementary Software "FlashMap 1. 0"), a shortcut to "FlashMap" should be placed on the desktop (Fig. 3A1 ) as well as all the images which will be analysed. After starting "FlashMap", a first window appears where the name of the study as well as green and red channels need to be indicated. Following this step a second window opens for guiding the user to define the settings of the analysis to be performed. For illustrative purposes, we chose to analyse one microdomain in one section (number of sections: 1; frequency of sections: 1). The thickness of the sections (here 50 µm) and the µm/pixel ratio also need to be defined (here 0.
7A2 ; see also Supplementary Fig. S5B ). Finally, "work values" from individual animals are processed to obtain an averaged representation of SVZ thickness or ODs distribution (Fig. 7A3 ; see also Supplementary Fig. S5C ). As an illustration of this approach, we averaged 3 datasets of SVZ thickness from independent analyses (Fig. 7B ). The resulting map generated by "FlashMap" accurately reflects the spatial organisation of the SVZ, while integrating inter-individual variability.
Discussion Our results establish "FlashMap" as a useful tool for a rapid spatial analysis of marker expression along both the rostro-caudal and dorso-ventral coordinates of the postnatal SVZ. Analysis of select markers highlight marked spatial differences along the SVZ in term of germinal activity and distribution of progenitors of distinct lineages. This software will prove to be useful for systematic 3D analysis and representation of marker expression in the SVZ. The SVZ is an ill-defined region of the postnatal mouse forebrain. The SVZ is particularly thin and tortious, and our results further demonstrate that its cellular density greatly varies along its dorso-ventral and rostro-caudal dimensions. To perform the current study, we defined the dorsal, lateral and medial walls of the opened LV along its full rostro-caudal coordinates.
We also provide a more detailed Figure  7. Averaging of different datasets using "FlashMap". (A) List of steps performed by "FlashMap" for averaging datasets. All steps are performed ROI-by-ROI and section-by-section. In a first step the amount of probes is averaged (1), which allows to even out the amount of probes by dividing the values into 'subvalues" (2a) to calculate "base values" (2b) and generate "work values" (2c). Finally, the new "work values" are averaged by "FlashMap" (3). (B) Heatmaps represent the relative SVZ thickness of 3 independent analyses (n1, n2, n3) as well as an averaged heatmap generated by "FlashMap". Abbreviation: ROI, region of interest; SVZ, subventricular zone. For a more detailed illustration see also Supplementary Fig. S5. mapping of the density of proliferative cells in more caudal regions, where a large region of low germinal activity is clearly visible.
A. 0. 30) for OD analysis and assembled using the LAS X software (Leica Microsystems GmbH, Wetzlar, Germany). For accurate OD analysis, settings were carefully chosen to avoid signal saturation and were maintained throughout the acquisition. Image mosaics were exported in TIFF format (. tif) for further analysis. A Dapi series of 1/3 sections was used for generating the 3D brain and ventricular system models. Acquired mosaics were orientated using Photoshop (CS4). Contours of the brain and the ventricular system were drawn on individual sections using Neurolucida 360 (MBF Bioscience) to generate a 3D mesh. Meshes were saved in "obj" format and exported to the open-source 3D computer graphics software Blender (www. blender. org) for further editing. For optimal superimposition of 2D heatmaps onto the 3D ventricular system model, the three SVZ walls (medial, dorsal, lateral) were defined for UV unwrapping.
Individual heatmaps were then superimposed to the corresponding 2D UV projection to generate accurate 3D representations (see Fig. 2  for the workflow of the experimental design). All files listed below are provided as supplementary material: • Please contact the corresponding authors for a "Stand-alone "FlashMap" version 1. 0 (see Supplementary software "FlashMap 1. 0") for analysis of complete or subsampled series of brain sections for the generation of complete 2D heatmaps, as well as the averaging of groups of animals. • Blender (www. blender. org) file template for the generation of 3D heatmaps (see Supplementary Blender file "Template 3D Heatmap"). The template contains a 3D reconstruction of a P10 mouse brain with simplified and unwrapped LV mesh. This template allows straight forward superimposition of 2D expression heatmaps on the 3D model.
Further, the file contains a camera fixed to a circular path around the brain for snapshots or 360° movies. • Example of a 360° movie of a 3D SVZ thickness heatmap (. mp4 file; see Supplementary Movie "3D SVZ Thickness"). Software generation -analysis. "FlashMap" was coded using the commercial coding software MATLAB (R2017a; The MathWorks) and a stand-alone version was generated to facilitate distribution and use by other researchers. The stand-alone version directly installs the MATLAB Runtime (v9. 2; The MathWorks), which is necessary for proper function of "FlashMap". "FlashMap" has been tested on Windows 7 and Windows 10. Windows 7 turned out to allow a more stable workflow and is therefore recommended. Description of the workflow for a complete "FlashMap" analysis is described in the current manuscript (see Fig.
Using JS div (3) the software estimates the optimal basal height of the probe (N opt ; height of the probe in pixels, where the value of the JS div consistently drops) between the apical and the basal borders N 0 and N max , respectively(4, 5). (G) Probes can be adjusted manually. (H) Complete the analysis by declining the request to proceed with another ROI (1) and another section(2). Export values (Excel files) and/or heatmaps in TIFF format (3). (I) Heatmaps of the lSVZ analysis.
Acknowledgements We are very grateful to  Kazuaki Yoshikawa  for providing us the guinea pig anti-Dlx2 antibody. The authors are very grateful to  Brian R. Rudkin  for the fruitful discussions and his constructive inputs. This study was supported by a Grant from the " Programme Avenir Lyon Saint-Etienne " and S. Z. was further supported by a  Doc. Mobility fellowship  from the  Swiss National Science Foundation  (SNF; grant number  P1SKP3_168418 ).
g. ,  Ilbert et al. 2010; Laigle et al. 2016)  proved very useful for identifying high-redshift galaxies (e. g. ,  Steinhardt et al. 2016). However, even with SPLASH, SEDS, and S-COSMOS, the most distant galaxies remained out of reach. Thus in Cycle 11, we began a program to cover three of the UltraVISTA ultradeep stripes to a much greater and more uniform depth with IRAC, so as to provide a much better match to the ground-based near-IR photometry, and over a wide area. This program is SMUVS: Spitzer Matching survey of the UltraVISTA ultra-deep Stripes, led by PI K. Caputi.
Because it lies so close to the ecliptic, each year the COSMOS field is only visible to Spitzer during two short observing windows roughly 40 days long and 6 months apart, February-March and July-August. SMUVS was designed to use just the first three available visibility windows, but intense scheduling pressure delayed its completion until 2017 March. Thus SMUVS required a total of five visits to COSMOS spread out over more than two calendar years (Table  1 ). Since the beginning of the mission, the UltraVISTA ultra-deep stripes therefore have up to 10 distinct imaging epochs in some locations, a feature of the dataset that is useful for exploring AGN variability in the near-infrared regime  (Sánchez et al. 2017). The individual exposures were organized into selfcontained segments known as Astronomical Observing Requests (AORs) roughly six hours long to accommodate the downlink schedule.
) Top three panels: area versus integration time within the three UltraVISTA stripes. Bottom panel: area versus integration time for all of SMUVS, i. e. , the sum of all three stripes. The data shown are derived from the full-mission IRAC mosaics, beginning with S-COSMOS  (Sanders et al. 2007 ) during the cryogenic mission and continuing through the fifth and final SMUVS epoch in 2017 April. At 30 hr integration times, SMUVS covers about 0. 3 deg 2 , but the coverage is variable. Nonetheless SMUVS is a significant improvement in all respects over, e. g. , SEDS, the COSMOS portion of which is shown in the lower panel with dotted lines. second, generating cutout images centered on those stars and cleaning them of nearby contaminating sources, and third, scaling and median-stacking the cutout im-   ages.
The positions of SMUVS sources are consistent with those from SEDS to within about 0. ′′ 12. Relative to 2MASS, the SMUVS source positions match to within about 0. ′′ 18 arcsec, consistent with what has been seen in earlier IRAC surveys. Fig. 7  compares SMUVS photometry to that from SEDS, S-COSMOS, and  Deshmukh et al. (2018). In all instances, the SMUVS photometry is consistent with previous measurements within the uncertainties, but the comparison reveals some systematic differences among the datasets, which are described here. Comparison to  Deshmukh et al. (2018) : the SMUVS photometry is compared to that of Deshmukh et al. Note-The SMUVS catalog of IRAC-detected sources in Stripe 1. The sources are listed in magnitude order. This table is available in its entirety in a machine-readable form in the online journal.
Figure2. Cumulative area coverage as a function of Spitzer/IRAC exposure time for SMUVS, including other, earlier observations (Table1. ) Top three panels: area versus integration time within the three UltraVISTA stripes. Bottom panel: area versus integration time for all of SMUVS, i. e. , the sum of all three stripes. The data shown are derived from the full-mission IRAC mosaics, beginning with S-COSMOS (Sanders et al. 2007 ) during the cryogenic mission and continuing through the fifth and final SMUVS epoch in 2017 April. At 30 hr integration times, SMUVS covers about 0. 3 deg 2 , but the coverage is variable. Nonetheless SMUVS is a significant improvement in all respects over, e. g. , SEDS, the COSMOS portion of which is shown in the lower panel with dotted lines.
This paper demonstrates how FAUST, a functional programming language for sound synthesis and audio processing, can be used to develop efficient audio code for the Web. After a brief overview of the language, its compiler and the architecture system allowing to deploy the same program as a variety of targets, the generation of WebAssembly code and the deployment of specialized WebAudio nodes will be explained. Several use cases will be presented. Extensive benchmarks to compare the performance of native and WebAssembly versions of the same set of DSP have be done and will be commented.
Extending the Web Audio API with FAUST The paper shows how the FAUST compilation chain has been moved to the Web. After a general introduction of the language and its compiler organization, developments done to target the WebAudio API and the recently defined WebAssembly low-level format will be detailed (section 4. 3 to 4. 5). As a Domain Specific Language targeting highly demanding mathematical code, generating We-bAssembly code from the FAUST language shows specific code generation issues that compiler writers in related domains could be interested in. Two main applications will be exposed: creating ready to use Web Audio nodes and HTML pages using the FAUST compiler in an offline manner, or even more interesting and flexible, embedding and using the compiler itself in Web pages (section 5).
Deploying the code The generated code is then combined with an architecture file describing how to relate the audio computation with the external world. Native audio drivers are developed as subclasses of a base audio class, controllers as subclasses of a base UI class. Typical Graphical  User Interface architectures are based on well established frameworks like QT or JUCE, and allow to display a ready to use window with sliders, text zones and buttons. Audio and UI parts are finally combined with the actual DSP computation to produce the final audio application or plugin (Figure  5 ). Thanks to this approach, the exact same source code can be used to generate native applications and plugins for more than 20 different targets, from VST and Unity plugins to Android applications, from embedded systems to Web Audio applications.
WEB AUDIO API The Web Audio API specification describes a high-level JavaScript API for processing and synthesizing audio in Web applications. The design model is based on an audio graph, where a set of AudioNode objects are created and connected together to describe the desired audio computation. The actual processing is usually executed in the underlying implementation (typically optimized Assembly/C++ code), and direct JavaScript processing and synthesis is also supported using the ScriptProcessorNode interface, in a non-real-time rendering context, thus possibly causing annoying audio glitches. The AudioWorklet specification 3  aims at improving the situation, having the audio graph definition done in the main thread, but rendering it (including user-defined nodes coded in pure JavaScript or WebAssembly) in a separated real-time thread.
The minimum viable product (MVP) specification has been finalized early 2017, with a binary format, as well as a textual format that looks like traditional assembly languages. WebAssembly is now officially supported in all major browsers. Porting well established C/C++ codebase with Emscripten 6  , like the Csound 7  framework as an example, or using DSL languages like FAUST, will then naturally benefit from improved and more stable performances.
Memory management. Modules work on linear memory blocks, contiguous, byte-addressable range of memory spanning from offset 0 and extending up to a varying memory size. Memory segments are either defined internally in the module, or imported from the JavaScript context. Since the DSP memory size is known at compile time, it is easy to define the proper memory layout to represent the DSP state. The memory block of the generated DSP contains the main DSP object, inlined sub-objects  9  , as well as audio buffers and their corresponding pointers  10. In C++, fields in the C++ object would be accessed using their name. In WebAssembly, memory has to be accessed using an index in the memory block. All fields indexes are thus computed in a preliminary compilation pass, as offsets from the DSP object base address, to be used later in the code for load/store operations.
When a single monophonic DSP object is generated, the module internal memory is used. In our own defined memory layout, we can decide to locate the DSP object at address 0, thus simplifying and speeding up access of the DSP fields, since they can simply be defined as offsets in the DSP object, without having to generate the code to add the DSP base address. Audio buffers and their pointers are placed after the DSP (Figure  6 ). If the DSP object is going to be used in a more complex memory layout (like when allocating several DSP objects in a polyphonic instrument for instance), a JavaScript created WebAssembly memory block is imported. Audio buffers and their pointers are placed starting at address 0 followed by DSP objects. Since the base address of each DSP will change, more complex field access code which adds the DSP base address and the field offset will be generated (Figure  7 ).
Functions generation. All FIR functions are compiled and exported in the module export section. Prototypes of required mathematical functions which are not part of the WebAssembly  9  The FAUST backend for a more structured langage like C++ typically generates sub-classes in this case. 10 At each cycle, audio buffers will be copied with data coming from the audio wrapper specification are generated in the module import section, to be retrieved from the enclosing JavaScript environment at execution time. Code for 32 or 64 bits float format can be generated, with the adapted version of mathematical functions and memory access code. Some specific functions like integer version of min/max functions (which are not yet part of WebAssembly specification) are internally generated and inlined in the resulting code.
Embedding the JavaScript FAUST compiler in the browser Since the Emscripten compiler helps deploying any C++ code on the Web, it becomes possible to compile the FAUST compiler itself with its embedded wasm backend in pure JavaScript and WebAssembly (Figure  8 ). It has been done by compiling the C++ libfaust library in a libfaust. js library combined with a libfaust. wasm file. A unique lowlevel createWasmCDSPFactoryFromString entry point has been defined, compiling the DSP source code using the wasm backend, and producing the module as an array of bytes and the helper JavaScript function as a string (Figure  9 ). Using WebAssembly API again and JavaScript eval function, allows to deploy it in the JavaScript context. Some additional glue code has been written, so that from the JavaScript side, a DSP factory will be created from the DSP source code with the following code: faust.
Programming Web Audio nodes with FAUST Self contained ready to use Web Audio nodes can be produced from a DSP source using the faust2wasm script, which basically calls the FAUST compiler targeting the wasm backend, then wraps the produced code with a generic JavaScript API to be usable in the Web Audio context. Audio nodes are created and activated. The full JSON description of the control parameters and their layout is available and can be used to create customized Graphical User Interfaces. Control parameters can then be read and written. This model has to be used when a custom control or Graphical User Interface is developed later on.
5. 3. 2 The FaustPlayground. The FaustPlayground application 18  lets the user develop an audio application by graphically connecting high-level modules written in FAUST. The source code can be dropped as a string, a file, or a Web URL, or loaded from a library of predefined modules included in the platform (Figure  12 ). Using libfaust. js, the DSP is compiled in the browser on the client machine, to become a functional Web Audio node that can be connected to others. At any time, the node source code can be edited and recompiled. The user can then export his work to all the platforms supported by the online compilation service, from pure standalone applications, various plugins formats (VST, Max/MSP. ), projects in source code form (JUCE, iOS. )  19. In order to perform this export, the graph must first be transformed into a single FAUST source code obtained by collecting the FAUST implementations of each node of the graph [4].
The WebAssembly approach promises near native performances for C/C++ written code compiled to WebAssembly using the Emscripten tool chain. Other languages like Rust (using the mir2wasm 20 tool) experiment with direct WebAssembly generation. It seems clear that as the WebAssembly specification and its implementation stabilizes, more and more languages will directly generate wasm to be deployed in browsers. The question of the code generation quality at each step of the compilation chain will rapidly emerge. Since our compiler is generating code for the quite focused audio domain, which is caracterized by a lot of memory access and mathematical operations, we can possibly expect to generate high quality code, even beating in some cases the generic Emscripten compilation chain based generated code.
While WebAssembly is initially designed to run on the Web, it may be deployed in non Web environnement like nodejs 21 , or even in standalone Virtual Machines like WAVM, developed in C++, which JIT compile WebAssembly to native code using the LLVM technology  22. Thus WebAssembly becomes a portable binary format that can be used in a large variety of situations. This is especially of interest for a DSL language like FAUST.
Optimizing the WAVM runtime for audio code The WAVM runtime strictly conforms to the WebAssembly specification, thus behaving as an interesting base reference. In the audio domain, the C/C++ generated code is usually compiled with specific optimization flags  24. Since C++ WAVM runtime can be quite easily modified, we did several changes into the reference implementation to improve the generated code performances (Figure  14 ). • removing the atomic flag in all load/store 25  that are added to pass all spec WebAssembly tests • adding the equivalent of -fast-math compilation flag that has to be done at LLVM IR and JIT (= native) 26  generation steps • and finally simplifying some mathematical operators, using their standard definition 27  instead of the specific WAVM coded ones that strictly implement the WebAssembly official semantic  28  (see for instance the definition of f32.
Float denormal handling The software float denormal code can be easily tested in the WAVM machine  30. Here is the result of code generated with -ftz from 0 to 2 (Figure  16 ). The code is continuously a bit slower when software FTZ is activated, the point being obviously to avoid pathological cases where the CPU consumption would raise dramatically in the presence of denormals values. The -ftz 2 mode appears to be the most efficient one and will preferably be used. 29 https://github. com/WebAssembly/binaryen 30 by explicitly deactivating hardware FTZ mode on the CPU running in this native runtime. Figure 16 Figure 17.
Emscripten versus FAUST direct compilation Wasm code directly generated by the FAUST wasm backend can be compared to wasm code generated by compiling (with Emscripten) the code generated by the FAUST C backend. All sophisticated optimizations passes the LLVM based Emscripten compiler can possibly be used on the C side, a simpler FIR to wasm generation model, but coupled with some specific optimizations (for instance the optimized memory layout one described in section 4. 2. 2) on the direct wasm side. Compilation of FAUST generated C has been done using -s SIDE_MODULE=1 mode to produce a light wasm module, without any runtime, to be loaded and activated by additional JavaScript glue code. Done under Firefox Nightly, the diagram shows that direct wasm code generation can even beat Emscripten generated wasm code (Figure  17 ).
Comparing the Chrome, Firefox and WebKit browsers on the tested machine shows that Chrome was the fastest engine in most cases (at the time of testing), with Firefox and WebKit quite similar (with a slight plus for WebKit). Comparing the Chrome browser with native engines shows results from 4,8 times slower (filterBank. dsp), 2,8 times slower (sTunedBar6. dsp) up to much more favorable cases (karplus32. dsp). Note that filterBank. dsp example is a bit of a pathological case, since Chrome is significantly slower than Firefox and WebKit in this case, and filterBank. dsp uses a lot of pow(10, x) code that is rewritten and optimized as exp10(x) with the C++ backend path. And finally it has to be said that all those benchmarks compare the browsers and the WAVM standalone runtime at time t, in a fast changing situation that hopefully will improve progressively.
Collection of annotated sequences We quantified the total number of acidic mammalian chitinase genes (CHIAs) in the genomes of 107 placental mammal species (table  S1 ), using both annotated gene models (88 species, 54 families, and 17 orders) and direct queries of genomic contigs (74 species, 62 families, and 19 orders; fig. S7 ), with 55 species overlapping between the two data sets. All genomes examined were available in National Center for Biotechnology Information (NCBI)'s nucleotide collection and wholegenome shotgun (WGS) contig database except three assemblies generated using the Discovar de novo protocol (Tamandua tetradactyla, Chaetophractus vellerosus, and Tolypeutes matacus; https://software. broadinstitute. org/software/discovar/blog/) and made available to us by the Broad Institute.