Code Paths Research Articles

Automatic compensation system for eccentricity error of absolute optical encoder.

Eccentric error is a vital part of high-precision optical encoder error. An automatic error compensation system is designed to lower the eccentric error of the encoder. On the periphery of the fan-shaped code path of the traditional encoder disk, a set of radial code paths is drawn. This radial code path is composed of several concentric circles with alternating light and dark lines. The direction of the radial code path is perpendicular to the direction of the fine code path. When the encoder rotates, the eccentricity of the encoder disk is measured by the moiré fringe signal output from the radial code channel. Based on the eccentricity error compensation algorithm, the eccentricity error of the encoder disk is compensated in real time to enhance the accuracy of the encoder. The experimental results of an encoder show that the mean square error of the encoder before the eccentricity error compensation is 21.25 arc seconds, and it is 3.66 arc seconds after compensation by this algorithm. The algorithm can significantly compensate the error caused by the eccentricity of the encoder and greatly improve the accuracy of the encoder.

Trinity: High-Performance and Reliable Mobile Emulation through Graphics Projection

Mobile emulation, which creates full-fledged software mobile devices on a physical PC/server, is pivotal to the mobile ecosystem. Unfortunately, existing mobile emulators perform poorly on graphics-intensive apps in terms of efficiency and compatibility. To address this, we introduce graphics projection , a novel graphics virtualization mechanism that adds a small-size projection space inside the guest memory, which processes graphics operations involving control contexts and resource handles without host interactions. While enhancing performance, the decoupled and asynchronous guest/host control flows introduced by graphics projection can significantly complicate emulators’ reliability issue diagnosis when faced with a variety of uncommon or non-standard app behaviors in the wild, hindering practical deployment in production. To overcome this drawback, we develop an automatic reliability issue analysis pipeline that distills the critical code paths across the guest and host control flows by runtime quarantine and state introspection. The resulting new Android emulator, dubbed Trinity, exhibits an average of 97% native hardware performance and 99.3% reliable app support, in some cases outperforming other emulators by more than an order of magnitude. It has been deployed in Huawei DevEco Studio, a major Android IDE with millions of developers.

DAFuzz: data-aware fuzzing of in-memory data stores.

Fuzzing has become an important method for finding vulnerabilities in software. For fuzzing programs expecting structural inputs, syntactic- and semantic-aware fuzzing approaches have been particularly proposed. However, they still cannot fuzz in-memory data stores sufficiently, since some code paths are only executed when the required data are available. In this article, we propose a data-aware fuzzing method, DAFuzz, which is designed by considering the data used during fuzzing. Specifically, to ensure different data-sensitive code paths are exercised, DAFuzz first loads different kinds of data into the stores before feeding fuzzing inputs. Then, when generating inputs, DAFuzz ensures the generated inputs are not only syntactically and semantically valid but also use the data correctly. We implement a prototype of DAFuzz based on Superion and use it to fuzz Redis and Memcached. Experiments show that DAFuzz covers 13~95% more edges than AFL, Superion, AFL++, and AFLNet, and discovers vulnerabilities over 2.7× faster. In total, we discovered four new vulnerabilities in Redis and Memcached. All the vulnerabilities were reported to developers and have been acknowledged and fixed.

Dual-path Network for Liver and Tumor Segmentation in CT Images Using Swin Transformer Encoding Approach.

Liver and tumor segmentation from CT images is a complex and crucial step in achieving full-course adaptive radiotherapy and also plays an essential role in computer-aided clinical diagnosis systems. Deep learning-based methods play an important role in achieving automatic segmentation. This research aims to improve liver tumor detection performance by proposing a dual path feature extracting strategy and employing Swin-Transformer. The hierarchical Swin-Transformer is embedded into the encoder and decoder and combined with CNN to form a dual coding path structure incorporating long-range dependencies and multi-scale contextual connections to capture coarse-tuned features at different semantic scales. The features of the two encoding paths and the upsampling path are fused, tested and validated with LITS and in-house datasets. The proposed method has a DG of 97.95% and a DC of 96.2% for liver segmentation; a DG of 80.6% and a DC of 68.1% for tumor segmentation; and a classification study of the tumor dataset shows a DG of 91.1% and a DC of 87.2% for large and continuous tumors and a DG of 71.7% and a DC of 66.4% for small and scattered tumors. Swin-Transformer can be used as a robust encoder for medical image segmentation networks and, combined with CNN networks, can better recover local spatial information and enhance feature representation. Accurate localization before segmentation can achieve better results for small and scattered tumors.

Online Code Layout Optimizations via OCOLOS

<italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">The processor front-end has become an increasingly important bottleneck in recent years due to growing application code footprints, particularly in data centers. Profile-guided optimizations performed by compilers represent a promising approach, as they rearrange code to maximize instruction cache locality and branch prediction efficiency along a relatively small number of hot code paths. However, these optimizations require continuous profiling and rebuilding of applications to ensure that the code layout matches the collected profiles. In this paper, we propose OCOLOS, the first online code layout optimization system for unmodified applications written in unmanaged languages. OCOLOS allows profile-guided optimization to be performed on a running process, instead of being performed offline and requiring the application to be re-launched. Our experiments show that OCOLOS can accelerate MySQL by up to 41%.</i>

BejaGNN: behavior-based Java malware detection via graph neural network.

As a popular platform-independent language, Java is widely used in enterprise applications. In the past few years, language vulnerabilities exploited by Java malware have become increasingly prevalent, which cause threats for multi-platform. Security researchers continuously propose various approaches for fighting against Java malware programs. The low code path coverage and poor execution efficiency of dynamic analysis limit the large-scale application of dynamic Java malware detection methods. Therefore, researchers turn to extracting abundant static features to implement efficient malware detection. In this paper, we explore the direction of capturing malware semantic information by using graph learning algorithms and present BejaGNN (Behavior-based Java malware detection via Graph Neural Network), a novel behavior-based Java malware detection method using static analysis, word embedding technique, and graph neural network. Specifically, BejaGNN leverages static analysis techniques to extract ICFGs (Inter-procedural Control Flow Graph) from Java program files and then prunes these ICFGs to remove noisy instructions. Then, word embedding techniques are adopted to learn semantic representations for Java bytecode instructions. Finally, BejaGNN builds a graph neural network classifier to determine the maliciousness of Java programs. Experimental results on a public Java bytecode benchmark demonstrate that BejaGNN achieves high F1 98.8% and is superior to existing Java malware detection approaches, which verifies the promise of graph neural network in Java malware detection.

Visualising data science workflows to support third-party notebook comprehension: an empirical study

Data science is an exploratory and iterative process that often leads to complex and unstructured code. This code is usually poorly documented and, consequently, hard to understand by a third party. In this paper, we first collect empirical evidence for the non-linearity of data science code from real-world Jupyter notebooks, confirming the need for new approaches that aid in data science code interaction and comprehension. Second, we propose a visualisation method that elucidates implicit workflow information in data science code and assists data scientists in navigating the so-called garden of forking paths in non-linear code. The visualisation also provides information such as the rationale and the identification of the data science pipeline step based on cell annotations. We conducted a user experiment with data scientists to evaluate the proposed method, assessing the influence of (i) different workflow visualisations and (ii) cell annotations on code comprehension. Our results show that visualising the exploration helps the users obtain an overview of the notebook, significantly improving code comprehension. Furthermore, our qualitative analysis provides more insights into the difficulties faced during data science code comprehension.

SQMBox: Interfacing a semiempirical integral library to modular ab initio electronic structure enables new semiempirical methods.

Ab initio and semiempirical electronic structure methods are usually implemented in separate software packages or use entirely different code paths. As a result, it can be time-consuming to transfer an established ab initio electronic structure scheme to a semiempirical Hamiltonian. We present an approach to unify ab initio and semiempirical electronic structure code paths based on a separation of the wavefunction ansatz and the needed matrix representations of operators. With this separation, the Hamiltonian can refer to either an ab initio or semiempirical treatment of the resulting integrals. We built a semiempirical integral library and interfaced it to the GPU-accelerated electronic structure code TeraChem. Equivalency between ab initio and semiempirical tight-binding Hamiltonian terms is assigned according to their dependence on the one-electron density matrix. The new library provides semiempirical equivalents of the Hamiltonian matrix and gradient intermediates, corresponding to those provided by the ab initio integral library. This enables the straightforward combination of semiempirical Hamiltonians with the full pre-existing ground and excited state functionality of the ab initio electronic structure code. We demonstrate the capability of this approach by combining the extended tight-binding method GFN1-xTB with both spin-restricted ensemble-referenced Kohn-Sham and complete active space methods. We also present a highly efficient GPU implementation of the semiempirical Mulliken-approximated Fock exchange. The additional computational cost for this term becomes negligible even on consumer-grade GPUs, enabling Mulliken-approximated exchange in tight-binding methods for essentially no additional cost.

Metaheuristics with variable diversity control and neighborhood search for the Heterogeneous Site-Dependent Multi-depot Multi-trip Periodic Vehicle Routing Problem

The planning of vehicle routes is a major issue involved in supply chains. In real environment, we can find situations involving a very large number of clients or constraints which indicate that exact methods should be avoided. In this context, this paper presents two metaheuristcs which are used to solve a complex problem named the Heterogeneous Site-Dependent Multi-depot Multi-trip Periodic Vehicle Routing Problem (HSDMDMTPVRP). The HSDMDMTPVRP is a real problem found in the automotive industry and considers several well-known Vehicle Routing Problems (VRP). The first metaheuristic is an adaptation of the Unified Hybrid Genetic Search (UHGS) which considers an advanced diversity control, feasibility control and a restart mechanism. The second one is a new metaheuristic named Adaptive Variable Neighborhood Race (AVNR) which combines variable neighborhood search and adaptive mechanisms integrated with a shrinking population managed with a diversity mechanism. Both approaches are also used for solving some variants of the VRP: Heterogeneous VRP, Site dependent VRP, Periodic VRP and Multi-trip VRP. Our computational experiments used 398 available instances in the literature with generic code path and also present 20 new instances for the HSDMDMTPVRP. The metaheuristics solved all instances with only one set of parameters and the results outperform or present the same solutions found by several state-of-the-art algorithms, showing the good performance of the approaches. Out of the 398 previously tested literature instances, the proposed metaheuristics found 140 new best-known solutions and 209 of the best-known ones. For the remaining instances, both approaches found results very close to best ones known.

Enhanced Multi-Verse Optimizer (TMVO) and Applying it in Test Data Generation for Path Testing

Data testing is a vital part of the software development process, and there are various approaches available to improve the exploration of all possible software code paths. This study introduces two contributions. Firstly, an improved version of the Multi-verse Optimizer called Testing Multi-Verse Optimizer (TMVO) is proposed, which takes into account the movement of the swarm and the mean of the two best solutions in the universe. The particles move towards the optimal solution by using a mean-based algorithm model, which guarantees efficient exploration and exploitation. Secondly, TMVO is applied to automatically develop test cases for structural data testing, particularly path testing. Instead of automating the entire testing process, the focus is on centralizing automated procedures for collecting testing data. Automation for generating testing data is becoming increasingly popular due to the high cost of manual data generation. To evaluate the effectiveness of TMVO, it was tested on various well-known functions as well as five programs that presented unique challenges in testing. The test results indicated that TMVO performed better than the original MVO algorithm on the majority of the tested functions.

Adaptive Path Selection for Dynamic Image Captioning

Image captioning is a challenging task, i.e., given an image machine automatically generates natural language that matches its semantic content and has attracted much attention in recent years. However, most existing models are designed manually, and their performance depends heavily on the expert experience of the designer. In addition, the computational flow of the model is predefined, and hard and easy samples will share the same coding path and easily interfere with each other, thus confusing the learning of the model. In this paper, we propose a Dynamic Transformer to change the encoding procedure from sequential to adaptive, i.e., data-dependent computing paths. Specifically, we design three different types of visual feature extraction blocks and deploy them in parallel at each layer to construct a multi-layer routing space in a fully connected manner. Each block contains a calculation unit that performs the corresponding operations and a routing gate that learns to adaptively select the direction to pass the signal based on the input image. Thus, our model can achieve a robust visual representation by exploring potential visual feature extraction paths. We evaluate our method quantitatively and qualitatively using a benchmark MSCOCO image caption dataset and perform extensive ablation studies to investigate the reasons behind its effectiveness. The experimental results show that our method is significantly superior to previous state-of-the-art methods.

Unleashing Coveraged-Based Fuzzing Through Comprehensive, Efficient, and Faithful Exploitable-Bug Exposing

Fuzzing has become an essential means of finding software bugs. Bug finding through fuzzing requires two parts—exploring code paths to reach bugs and exposing bugs when they are reached. Existing fuzzing research has primarily focused on improving code coverage but not on exposing bugs. Sanitizers such as AddressSanitizer (ASAN) and MemorySanitizer (MSAN) have been the dominating tools for exposing bugs. However, sanitizer-based bug exposing has the following limitations. (1) sanitizers are not compatible with each other. (2) sanitizers incur significant runtime overhead. (3) sanitizers may generate false positives, and (4) exposed bugs may not be exploitable. To address these limitations, we propose <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Expozzer</small> , a fuzzing system that can expose bugs comprehensively, efficiently, and faithfully. The intuition of <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Expozzer</small> is to detect bugs through divergences in a properly diversified dual-execution environment, which does not require maintaining or checking execution metadata. We design a practical and deterministic dual-execution engine, a co-design for dual-execution and fuzzers, bug-sensitive diversification, comprehensive, and efficient divergence detection to ensure the effectiveness of <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Expozzer</small> . The results of evaluations show that <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Expozzer</small> can detect not only CVE-assigned vulnerabilities reliably, but also new vulnerabilities in well-tested real-world programs. <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Expozzer</small> is 10 times faster than MemorySanitizer and is similar to AddressSanitizer.

Human Segmentation and Tracking Survey on Masks for MADS Dataset.

Human segmentation and tracking often use the outcome of person detection in the video. Thus, the results of segmentation and tracking depend heavily on human detection results in the video. With the advent of Convolutional Neural Networks (CNNs), there are excellent results in this field. Segmentation and tracking of the person in the video have significant applications in monitoring and estimating human pose in 2D images and 3D space. In this paper, we performed a survey of many studies, methods, datasets, and results for human segmentation and tracking in video. We also touch upon detecting persons as it affects the results of human segmentation and human tracking. The survey is performed in great detail up to source code paths. The MADS (Martial Arts, Dancing and Sports) dataset comprises fast and complex activities. It has been published for the task of estimating human posture. However, before determining the human pose, the person needs to be detected as a segment in the video. Moreover, in the paper, we publish a mask dataset to evaluate the segmentation and tracking of people in the video. In our MASK MADS dataset, we have prepared 28 k mask images. We also evaluated the MADS dataset for segmenting and tracking people in the video with many recently published CNNs methods.

Develop an Appropriate Model for the Role of Pressure Groups in the linear Formation of Iran's General Policy

Politics involves decision-making, and decisions are the result of group conflict. Political decisions are nothing but the result of the interaction of pressure groups and the relationship of power between them. Pressure groups try to present their demands to the political system and public policy. To. A pressure group is a group of people who have political goals and want to influence the law, and a stakeholder group is a group of people who have common interests and do not have political goals. Pressure groups can be examined from two perspectives. The classical view that the performance of pressure groups disrupts the political system and public policy; and the modern view that not only does not reject the performance of pressure groups, but also considers the existence of these groups as a dynamic aspect of the organization and a tool to improve public participation. brings. One of the biggest areas of action for pressure groups is the legislature and parliaments. The role of pressure groups in shaping public policy with the foundation data theory approach is through the three stages of open, central and selective coding. The statistical participants are the current and periodic members of parliament in the country. Using purposive sampling method, semi-structured interviews were conducted with 22 members of parliament in an 18-month period until the data saturation stage was reached. Members were validated by matching methods. The present research is a mixed type, so data analysis consists of two phases, qualitative and quantitative. In the qualitative phase, to analyze and interpret (codify) the concepts expressed by members of parliament and experts. Iran is covered, which includes open, axial and selective coding. In addition, Delphi method has been used for localization and screening of indicators. Data analysis has been used using MaxQDA2012, Excel2016 and SPSS software. Open, axial and selective coding was used to analyze the data. During the data comparison process in the open, axial and selective coding path, 132 concepts, 71 subcategories and 24 general categories were obtained and presented in the form of a paradigm model. The integration of categories, based on the existing relationships between them, around the involvement of groups in professional activities, formed a paradigm model that reflected the development of an appropriate model of the role of pressure groups in shaping public policy. Causal conditions (influence of pressure groups on decisions, indirect influence on public opinion, party orientation, incorrect structure of democracy, lack of holistic view, etc.), central category (gaining benefits and advantages, adaptation of pressure groups to policy needs General (intervention) conditions (use of coercive tools of influence, behind-the-scenes issues and interference of officials in each other) strategies (dissemination of information, use of powerful people, transparency and defeat of monopolies) and consequences (promise, policy-making citizen and unity and integrity) emerged and Relationships between different dimensions were shown through the formation of a conceptual model. Finally, legal propositions and strategic hypotheses of the research were developed.

An Approach for Detecting Feasible Paths Based on Minimal SSA Representation and Symbolic Execution

Static analysis is one of the techniques used today to analyze source codes and minimize the issue of software vulnerability. Static analysis has the ability to observe all possible software paths in an application through the scrutiny of a web application’s source code. Among those paths, some may be considered feasible paths, which refer to any paths that the test cases can execute. The detection of feasible paths in the results of a static analysis helps to minimize the false positive rate. However, the detection of feasible paths can be challenging, especially for programs that have multiple conditions in the same branch. The aim is to ensure that each feasible path is detected only once (not duplicated). This paper proposes an approach based on minimal static single assignment (MSSA) form and symbolic execution to detect feasible paths. The proposed approach starts by converting the source code into an abstract syntax tree (AST), followed by converting the AST to minimal SSA representation, which helps to decrease the number of instructions in the SSA form. An algorithm was built to examine all of the instructions of the SSA form, identify whole paths in the source code, and extract constraints along each path. A path weight method (PWM) is proposed in this work to avoid detecting duplicated feasible paths. The satisfiability modulo theory (SMT) solver was used to check the satisfiability of each path condition. The proposed approach was tested on seven well-known test programs that have been used in related studies and 10 large scale programs. The experimental results indicate that the proposed method (PWM) can avoid detecting duplicated feasible paths, and the proposed approach reduced the time required for generating the paths compared to that in related studies.

Boosting Free-Energy Perturbation Calculations with GPU-Accelerated NAMD.

Harnessing the power of graphics processing units (GPUs) to accelerate molecular dynamics (MD) simulations in the context of free-energy calculations has been a longstanding effort toward the development of versatile, high-performance MD engines. We report a new GPU-based implementation in NAMD of free-energy perturbation (FEP), one of the oldest, most popular importance-sampling approaches for the determination of free-energy differences that underlie alchemical transformations. Compared to the CPU implementation available since 2001 in NAMD, our benchmarks indicate that the new implementation of FEP in traditional GPU code is about four times faster, without any noticeable loss of accuracy, thereby paving the way toward more affordable free-energy calculations on large biological objects. Moreover, we have extended this new FEP implementation to a code path highly optimized for a single-GPU node, which proves to be up to nearly 30 times faster than the CPU implementation. Through optimized GPU performance, the present developments provide the community with a cost-effective solution for conducting FEP calculations. The new FEP-enabled code has been released with NAMD 3.0.

The Role of Postprocessor in the Translation of Vector Graphics Understandable to the CNC Machine Controller

The purpose of this paper is to show the post-processor role and importance in the creation of programming code which CNC machine controller can understand and proceed. Today, the use of CNC technology introduces the Industry 4.0 principles in the production, thus increasing the productivity and precision of the produced parts. It is very important to optimize all the production steps, from choosing the right CAD software for vectors drawing, defining tools and generating tool paths, creating and optimizing post-processor, to translating the tool paths in the programming code which controller of the CNC machine can understand, as well as educating the operators to be able to calibrate the machine and understand and run the CNC programming code properly. When all the abovementioned steps are correctly defined, the production can be optimized and best results are guaranteed.

When one vulnerable primitive turns viral: Novel single-trace attacks on ECDSA and RSA

Microarchitecture based side-channel attacks are common threats nowadays. Intel SGX technology provides a strong isolation from an adversarial OS, however, does not guarantee protection against side-channel attacks. In this paper, we analyze the security of the mbedTLS binary GCD algorithm, an implementation that offers interesting challenges when compared for example with OpenSSL, due to the usage of very tight loops in the former. Using practical experiments we demonstrate the mbedTLS binary GCD implementation is vulnerable to side-channel analysis using the SGX-Step framework against mbedTLS based SGX enclaves.We analyze the security of some use cases of this algorithm in this library, resulting in the discovery of a new vulnerability in the ECDSA code path that allows a single-trace attack against this implementation. This vulnerability is three-fold interesting:&#x0D; &#x0D; It resides in the implementation of a countermeasure which makes it more dangerous due to the false state of security the countermeasure currently offers.&#x0D; It reduces mbedTLS ECDSA security to an integer factorization problem.&#x0D; An unexpected GCD call inside the ECDSA code path compromises the countermeasure.&#x0D; &#x0D; We also cover an orthogonal use case, this time inside the mbedTLS RSA code path during the computation of a CRT parameter when loading a private key. The attack also exploits the binary GCD implementation threat, showing how a single vulnerable primitive leads to multiple vulnerabilities. We demonstrate both security threats with end-to-end attacks using 1000 trials each, showing in both cases single-trace attacks can be achieved with success rates very close to 100%.

Recent developments in histogram libraries

Boost.Histogram, a header-only C++14 library that provides multidimensional histograms and profiles, became available in Boost 1.70. It is extensible, fast, and uses modern C++ features. Using template metaprogramming, the most efficient code path for any given configuration is automatically selected. The library includes key features designed for the particle physics community, such as optional under- and overflow bins, weighted increments, reductions, growing axes, thread-safe filling, and memory-efficient counters with high-dynamic range. Python bindings for Boost.Histogram are being developed in the Scikit-HEP project to provide a fast, easy-to-install package as a backend for other Python libraries and for advanced users to manipulate histograms. Versatile and efficient histogram filling, effective manipulation, multithreading support, and other features make this a powerful tool. This library has also driven package distribution efforts in Scikit-HEP, allowing binary packages hosted on PyPI to be available for a very wide variety of platforms. Two other libraries fill out the remainder of the Scikit-HEP Python histogramming effort. Aghast is a library designed to provide conversions between different forms of histograms, enabling interaction between histogram libraries, often without an extra copy in memory. This enables a user to make a histogram in one library and then save it in another form, such as saving a Boost.Histogram in ROOT. And Hist is a library providing friendly, analyst-targeted syntax and shortcuts for quick manipulations and fast plotting using these two libraries.

Improving bug detection via context-based code representation learning and attention-based neural networks

Bug detection has been shown to be an effective way to help developers in detecting bugs early, thus, saving much effort and time in software development process. Recently, deep learning-based bug detection approaches have gained successes over the traditional machine learning-based approaches, the rule-based program analysis approaches, and mining-based approaches. However, they are still limited in detecting bugs that involve multiple methods and suffer high rate of false positives. In this paper, we propose a combination approach with the use of contexts and attention neural network to overcome those limitations. We propose to use as the global context the Program Dependence Graph (PDG) and Data Flow Graph (DFG) to connect the method under investigation with the other relevant methods that might contribute to the buggy code. The global context is complemented by the local context extracted from the path on the AST built from the method’s body. The use of PDG and DFG enables our model to reduce the false positive rate, while to complement for the potential reduction in recall, we make use of the attention neural network mechanism to put more weights on the buggy paths in the source code. That is, the paths that are similar to the buggy paths will be ranked higher, thus, improving the recall of our model. We have conducted several experiments to evaluate our approach on a very large dataset with +4.973M methods in 92 different project versions. The results show that our tool can have a relative improvement up to 160% on F-score when comparing with the state-of-the-art bug detection approaches. Our tool can detect 48 true bugs in the list of top 100 reported bugs, which is 24 more true bugs when comparing with the baseline approaches. We also reported that our representation is better suitable for bug detection and relatively improves over the other representations up to 206% in accuracy.