Abstract: A method includes extracting information from an unstructured data source, the method including: scraping, by at least one processor, a plurality of texts from the unstructured data source, extracting, by the at least one processor, from the plurality of texts a chunk of relevant text, summarizing, by the at least one processor, using a pre-trained summarizer, the chunk of relevant text to obtain semi-structured information comprising a set of sentences that summarize the chunk of relevant texts, and postprocessing, by the at least one processor, the semi-structured information to obtain structured information. The method can be executed highly efficiently, in particular on massively parallel hardware.

Abstract: A resource sharing marketplace platform includes a back-office server including a controller adapted to run a plurality of integrated systems and a wireless communication module in communication with the controller, wherein, the resource sharing marketplace platform is adapted to receive a request from a user, collect data from a plurality of acceptable service providers, and provide a response to the user.

Abstract: Methods and systems define an operational methodology for a relationship-based programming tool and use the operational methodology to operate the relationship-based programming tool.

Abstract: Disclosed herein is a method that supports queries deploying operators based on multiple programming languages at least through determining schema compatibility between neighboring operators within a query. Upon receipt of a query, a sequence of operators of the query is identified, where the sequence of operators includes at least two neighboring operators including a first operator and a second operator representing a machine learning model. By determining schema compatibility between at least the first and second operators, the method either alerts a user to schema incompatibility before attempting to execute the query or determine that the schemas are compatible such that the query may be executed without the occurrence of errors due to schema incompatibility between neighboring operators. Advantageously, the method enables the integration of a machine learning model into the query while still ensuring schema compatibility.

Abstract: Devices and techniques are generally described for machine learning hardware optimization. In some examples, a first computing device may receive first data describing a first machine learning model. A first operator type and a first input size for a first layer of the first machine learning model may be determined from the first data. First executable code may be generated that defines a first operator for the first layer of the first machine learning model. The first operator may be specific to the first input size and the first operator type. The first executable code may be stored in non-transitory computer-readable memory. In some examples, second data may be input into the first machine learning model. The first machine learning model may process the second data to generate first output data based at least in part on execution of the first code.

Abstract: System, method, and circuitry for generating a linker model for use by a toolchain associated with a programmable computing device. One or more regions in the memory resources available to the programmable computing devices is defined for used by an application executing on the programmable computing device. One or more sections is defined for those regions for use by the application. Resource boundaries are generated for the application based on the defined regions and the defined sections. A user is enabled to modify the defined regions or the defined sections or the generated resource boundaries. A linker model is then generated based on the available memory resources, the defined regions, the defined sections, and the generated resource boundaries. This linker model is then utilized to generate a linker script for the programmable computing device based the linker syntax compatible with a toolchain linker for the programmable computing device.

Abstract: A method of decoding coding blocks of a coding tree unit for an image frame, from a bitstream. The method comprises determining a chroma format of the image frame, the chroma format having chroma channels of the image frame being subsampled relative to a luma channel of the image frame; and determining, based on the determined chroma format, a size of a chroma coding block of one of the chroma channels of the coding tree unit, wherein the chroma coding block is collocated with a plurality of corresponding luma blocks. The method comprises determining the chroma coding block is encoded using intra prediction if the determined size of the chroma block is a predetermined minimum chroma block size; and decoding the coding blocks of the coding tree using intra prediction for the chroma coding block and inter prediction for at least one of the plurality of corresponding luma coding blocks.

Abstract: A construction method and system for a visible near-infrared spectrum dictionary is provided. The method includes: constructing a four-primary color chromaticity cone by using normalized spectral response curves of four primary colors of a visible light camera as spectral basis functions; performing weighted combination on the spectral basis functions and forming an initial visible near-infrared spectrum dictionary; acquiring points on the four-primary color chromaticity cone on the basis of the initial visible red infrared spectrum dictionary according to different spectral resolutions and performing discretization, and forming words in the initial visible near-infrared spectrum dictionary; clustering chromaticity coordinates corresponding to the words into different groups, performing weighted combination on multi-scale spectral response curves corresponding to different group types, generating phrases or sentences in the dictionary, and generating a final visible near-infrared spectrum dictionary.

Abstract: Validation of correct derivation of a parallel program from a sequential program for deployment of the parallel program to a plurality of processing units is described. The system receives the program code of the sequential program and the program code of the parallel program. A static analysis component computes a first control flow graph, and determines dependencies within the sequential program code. It further computes a further control flow graph for each thread or process of the parallel program and determines dependencies within the further control flow graphs. A checking component checks if the sequential program and the derived parallel program are semantically equivalent by comparing the respective first and further control flow graphs and respective dependencies. A release component declares a correct derivation state for the parallel program to qualify the parallel program for deployment if the derived parallel program and the sequential program are semantically equivalent.

Abstract: Systems and methods are provided herein for natively interpreting logic across disparate platforms. Rather than executing server calls that are computationally expensive, logic may be extracted into code segments that can be evaluated at run time by an interpreter. The interpreter is passed a set of evaluators, features, and contextual data, each of which is expressed in a domain specific language. An evaluator maps an identifier to a rule and describes one or more contextual data fields with which the rule is to be evaluated. A feature corresponds to a logical condition that identifies the evaluator and a return value that is returned if the condition is met. The interpreter identifies the evaluator from the feature being evaluated and evaluates its corresponding rule based on the contextual data provided to return a return value. One or more operations may be performed based on the return value provided.

Abstract: Embodiments of a variable system for simulating the operation of an autonomous system, such as an autonomous vehicle, are disclosed. A layered approach for defining variables can allow changing the specification of those variables under the rules of override and refinement, while leaving the software components that query those variables at runtime unaffected. The variable system can facilitate, among others, deterministic sampling of variables, simulation variations, noise injection, and realistic message timing. These applications can make the simulator more expressive and more powerful by virtue of being able to test the same scenario under many different conditions. As a result, more exhaustive testing can be performed without requiring user intervention and without having to change the individual software components of the simulator.

Abstract: Embodiments described include systems and methods for using an HTML-based application integrated with an embedded browser on a client device, for trusted data transfer for instance. An HTML-based application within an embedded browser of a client device can provide access to a network application and its resources. The HTML-based application can establish a secure session for the network application between a server and the HTML-based application. The embedded browser can determine that the HTML-based application is a trusted application via application of one or more policies. With the secure session established and responsive to determining that the HTML-based application is a trusted application, the embedded browser may establish at least one virtual channel between the embedded browser and the HTML-based application. Using the at least one virtual channels, the embedded browser can transfer data between the secure session of the network application and the operating system (OS) of the client device.

Abstract: Various embodiments provide methods, systems, apparatus, computer program products, and/or the like for managing, ingesting, monitoring, updating, and/or extracting/retrieving information/data associated with an electronic record (ER) stored in an ER data store and/or accessing information/data from the ER data store, wherein the ERs are generated, updated/modified, and/or accessed via a graph-based domain ontology.

Abstract: Technology is described for a checkpoint service for code function checkpoints associated with instances of code functions executed by a computing hub in a local area network. Subsequent to the execution of a code function being suspended by the computing hub, the computing hub may generate a code function checkpoint describing the execution of the code function. The computing hub may persist the code function checkpoint to storage using a checkpoint service. The computing hub may create the code function checkpoint in response to monitoring metrics associated with the computing hub, such as processor overutilization. The computing hub may resume the execution of the code function at a later time using the code function checkpoint retrieved from the checkpoint service.

Abstract: A technique for efficient calling of functions on a processor generates an executable program having a function call by analysing an interface for the function that defines an argument expression and an internal value used solely within the function, and an argument declaration defining an argument value to be provided to the function when the program is run. A data structure is generated including the internal value and a resolved argument value derived from the argument expression and the argument value. A single instruction is encoded in the program to utilise the data structure. When the program is executed on a processor, the single instruction causes the processor to load the argument value and internal value from the data structure into registers in the processor, prior to evaluating the function. The function can then be executed without further register loads being performed.

Abstract: Automatic workflow generation is described. One or more files containing code statements for accessing and modifying information in a destination database is received. The code statements are parsed from the one or more files and dependencies between the code statements are determined. A dependency graph is built by arranging the code statements according to the dependencies between the code statements. The dependency graph is partitioned by identifying at least one barrier code statement having an unclear dependency and dividing the dependency graph between code statements occurring prior to the at least one barrier code statement and code statements occurring after the at least one barrier code statement. Jobs are scheduled based on the partitioned dependency graph, and the code statements are annotated according to the scheduled jobs. A workflow is then automatically generated based on the annotated code statements.

Abstract: A data processing system (10) connected to a plurality of first applications (80) and a plurality of second applications (90) includes a setting information generation function section (20), wherein the setting information generation function section includes a first interface generator (22) configured to generate a first interface for the first applications, a second interface generator (24) configured to generate a second interface for the second applications, and a storage (30) to store common data structure generation source information which is common information based on which the first and second interfaces are generated, and when the common data structure generation source information is updated, the first interface generator and the second interface generator automatically generate the first interface and the second interface, respectively, based on the updated common data structure generation source information.

Abstract: A method may include a obtaining a first data model instance comprising an identifier string and a set of attributes associated with a set of attribute name strings. The method may include obtaining an ontology graph that includes a first label, a second label, and an association between them. The method may include using a prediction model to select the first label based on the first data model instance and determining the second label based on the relationship. The method may include determining a selected set of labels that includes the first label and the second label to associate with the first data model instance. The method may include associating the selected set of labels with the first data model instance in a dataset that includes a plurality of records, where each record is associated with a different data model instance.

Abstract: A method facilitates development of instructions in a precise syntax, such as built-in functions of a computational system such as a spreadsheet application, using natural language (NL) input. A user may enter NL input in a workspace. An NL processing system may process the NL input to generate instruction(s) in a precise syntax that corresponds to the NL input. The instruction(s) in the precise syntax then may be included in the workspace.

Abstract: An improved method, system, and apparatus is provided to implement a general architecture for robot systems. A mode execution module is provided to universally execute execution modes on different robotic system. A system includes an execution module that receives software instructions in a normalized programming language. The system also includes an interface having a translation layer that converts the software instructions from the normalized language into robot-specific instructions that operate in a particular robotic system. The system further includes a controller that is communicatively coupled to the interface, wherein the controller receives the robot-specific instructions. Moreover, the system includes a robotic device that is operatively controlled by the controller by execution of the robot-specific instructions.

Abstract: The present invention relates to a method of converting logic written in software code into text, comprising: converting the code to a structured format that represents the logic described in each function of said code as a tree of elements, and mapping the elements of the structured format into corresponding counterparts in a target language for obtaining a text translation of the structured format.

Abstract: A computer-implemented method includes receiving, by a processor, an updated version of a computer program that includes several source code changes. A compiler preprocesses the source code changes for a target computing platform. The preprocessing includes identifying a compile time condition associated with one or more computer instructions enclosed by a macro, determining a current value of the compile time condition at the time of compiling, and determining corresponding object code based on the current value. Further, a macro information record for the macro is generated that includes the compile time condition, the current value, and an identification of the computer instructions. Further, a linker preprocesses the source code changes. This preprocessing includes determining that the object code is not included in an executable file, and updating the macro information record to indicate that the macro is not included in the executable file.

Abstract: Embodiments described herein provide techniques for in-line compiling of UDFs in other programming languages. These techniques enable faster programming iterations because it allows users to compile directly in the cloud processing system. Moreover, it allows the UDFs to tie into existing libraries. The compiled results are treated as sensitive and handled with appropriate security policies, as with any other user data in the system.

Abstract: Methods, systems, and apparatus, including computer programs stored on computer-readable media, generate contextually relevant electronic information cards. An indication to generate an electronic information card may be received from a user. In response to the indication, the electronic information card may be generated. A selection of a user interface field element may be received to add to the electronic information card at a location, and, in response to the selection, the user interface element may be added to the electronic information card at the location.

Abstract: The invention relates to a creating a stored procedure that retrieves its queries from a database, e.g., a DB2 table, and then prepares and executes dynamic SQL based on parameters supplied by a calling program. According to an embodiment of the present invention, a computer implemented system implements a dynamic stored procedure tool and comprises: a memory interface that accesses a database table; an interactive interface that receives a user selection; a processor, coupled to the memory interface and the interactive interface, the processor configured to perform the steps comprising: retrieve input values from a calling program; retrieve a cursor from an external source, using the input values; determine whether one or more parameter substitutions are applicable; and execute the cursor dynamically.

Abstract: Techniques for compiling source code include generating object code by processing source code corresponding to a portion of a software program. The source code includes an instruction, native to a program language, for a memory location access. Based at least in part on processing the source code, the compiler generates second object code that, when executed by one or more processors, configures the one or more processors to determine to implement the memory location access using first database access transaction operations or to implement the memory location access using second database access transaction operations. The compiler may generate third object code that configures the one or more processors to implement the memory location access using the first database access transaction operations or to implement the memory location access using the second database access transaction operations, based at least in part based on the determining.

Abstract: Embodiments of the present disclosure relate to a method, system, and computer program product for exception handling. In some embodiments, a method is disclosed. According to the method, in response to an application throwing an exception, a target stack frame for handling the exception is detected from a call stack of the application. The call stack comprises a plurality of stack frames. One of the plurality of stack frames corresponds to a function called by the application and supports either a one-phase exception handling mechanism or a two-phase exception handling mechanism. In response to the target stack frame being detected from the call stack, the target stack frame is caused to handle the exception. In other embodiments, a system and a computer program product are disclosed.

Abstract: A method for efficiently translating logic programming language code into structured query language (SQL) code that includes receiving input written in a logic programming language (LPL) that indicates a function that is defined in the LPL, but is not defined in a target SQL used to access a dataset, translating the input written in the LPL into the target SQL to generate translated SQL code, including transforming the function not defined in the target SQL into code for a series of functions that (i) are defined in the target SQL and (ii) together achieve a result of the function not defined in the target SQL, and executing the translated SQL code to achieve a result of the function that is not defined in the SQL, including executing the code for the series of functions that together achieve the results of the function that is not defined in the target SQL.

Abstract: A port is provided that utilized various techniques to manage contention for the same by controlling data that is written to and read from the port in multi-core assembly within a usable computing system. When the port is a sampling port, the assembly may include at least two cores, a plurality of buffers in operative communication with the at least one sampling ports, a non-blocking contention management unit comprising a plurality of pointers that collectively operate to manage contention of shared ports in a multi-core computing system. When the port is queuing port, the assembly may include buffers in communication with the queuing port and the buffers are configured to hold multiple messages in the queuing port. The assembly may manage contention of shared queuing ports in a multi-core computing system.

Abstract: Various methods, apparatuses/systems, and media for generating a two-dimensional selectable user experience (UX) element are disclosed. A client device having a graphical user interface (GUI) for receiving user input is configured to run interface applications. The client device is coupled with one or more server devices via a communication network. The one or more server devices provides user interface (UI) metadata. A processor causes a receiver to receive the UI metadata from the one or more server devices; generates, at the client device, a two-dimensional (2D) selectable user experience (UX) element based on the received UI metadata; receives a single action user input to select a single desired field, which conveys two desired actions, from the 2D selectable UX element; and executes the two desired actions based on the selected single desired field from the 2D selectable UX element.

Abstract: A server and a method for executing an application are provided. The method includes receiving code associated with an application uploaded from a terminal device, transmitting, to a service server, code information associated with the application, receiving, from the service server, execution information for executing the application acquired based on the code information, defining the accelerated computing environment for executing the application based on the received execution information, and executing the application in the compiled accelerated computing environment.

Abstract: Software lifecycle management includes, searching, using a processor, historical development data including prior development tasks for a software system. The searching is performed according to a current development task for the software system. A determination is made as to whether the current development task has an affinity with a selected prior development task implemented within the software system. A recommendation is provided for the current development task based upon the selected prior development task.

Abstract: Software lifecycle management includes, searching, using a processor, historical development data including prior development tasks for a software system. The searching is performed according to a current development task for the software system. A determination is made as to whether the current development task has an affinity with a selected prior development task implemented within the software system. A recommendation is provided for the current development task based upon the selected prior development task.

Abstract: A sequence control program and an HMI control program are synchronized and simulated. A program development support unit includes a calculation unit and a storage unit. A sequence control editing program for achieving a sequence control editing unit, an HMI control editing program for achieving an HMI control editing unit, and an integration simulation management program for achieving an integration simulation management unit are stored in the storage unit. The integration simulation management unit manages the synchronization of simulation of the sequence control program and simulation of the HMI control program. The integration simulation management unit executes variable management process. In the variable management process, common variables are exchanged between the sequence control program and the HMI control program during execution of the simulation of the sequence control program and the simulation of the HMI control program.

Abstract: Techniques are disclosed relating to retrieving data from an in-memory cache, such as that for a database system. In various embodiments, an in-memory cache receives a request from an application for data, where the request specifies a class having a function executable to access the data from a location external to the cache in response to a cache miss. The cache handles the request such that the cache miss is not returned to the application. Specifically, the cache, in some embodiments, determines whether it stores the requested data, and in response to determining that it does not store the data, calls the function of the class to access the data from the location external to the cache and receives the data returned by the execution of the function. The cache then stores the received data in the cache and returns the received data in response to the request.

Abstract: Systems and methods for displaying computer environment monitoring data can include a multi-tier cache memory associated with a processor of a first device. The multi-tier cache memory can include a first cache layer, and a second cache layer having a higher data access rate than the first cache layer. The first device can receive, from a second device, a data block including monitoring data selected based on user profile information associated with a user of the first device. The first device can store the data block in the first cache layer, and generate a first data sub-block using data from the data block having a higher priority for display as compared to other data of the data block. The first device can store the first data sub-block in the second cache layer, and provide the first data sub-block for display on a display device from the second cache layer.

Abstract: An improved model-based approach for undoing actions in an application that was not previously configured with an undo feature is disclosed. Object models are constructed for each object invoked by the application. Snapshots of the object model are captured after every action to preserve the object model state at different points in time. The object model includes an object tree data structure having multiple nodes comprising data and metadata for the object. The object model is frozen and editing of the object is only permitted via an undo management engine. In response to edits from the application, the undo management engine responds by unfreezing the path of object nodes from leaf node to root node in the object tree data structure. Edits are applied to the object model at the leaf node. The object model can then be re-frozen to maintain the state of the object after each action.

Abstract: In a session management method, when a first access and mobility management function (AMF) network element serving a terminal becomes unavailable, a service management function (SMF) network element obtains a pool identifier of an AMF pool that includes the first AMF, and queries a network repository function (NRF) entity to obtain the address or identifier of a second AMF in the same AMF pool. The SMF then triggers the second AMF network element to obtain a context of the terminal from a unstructured data storage function (UDSF) entity.

Abstract: Embodiments of the present invention disclose a method, a computer program product, and a computer system for mapping components of non-distributed environments to distributed environments. A computer receives a data pipeline configured for a non-distributed environment and identifies one or more bottleneck components of the data pipeline. In addition, the computer converts data used in the pipeline to a format compatible with a distributed environment and installs the necessary computing libraries necessary for operating the pipeline within the distributed environment. The computer further converts the code of the pipeline to a code that is compatible with the distributed environment and optimizes components of the pipeline for use in the distributed environment.

Abstract: Provided is a process of identifying an offers engine configured to provide information about offers to users, the method including: receiving, at an offers engine, a request for an offers interface website from a mobile computing device; and in response to the request, transmitting to the mobile computing device a website configured to cause a browser of the mobile computing device to perform steps, including: detecting an offers intent in the transmitted website; retrieving from memory of the mobile computing device an identifier of a native application offers interface mapped to the offers intent; and in response to retrieving the identifier of the offers engine, launching the native application, the native application being stored in memory of the mobile computing device and configured to provide an offers interface to the offers engine.

Abstract: Techniques are disclosed relating to modifying the functionality of software applications using object-oriented configuration data. In some embodiments, a configuration module may receive, from an application hosted within a server system, a request for configuration data that is usable to modify the manner in which the application performs a computing operation. In some embodiments, the request may specify a particular data object and include contextual information. The configuration may receive, from a configuration service in the server system, a configuration data package that includes a default definition for the particular data object and an override definition for a contextual override of the particular data object. The configuration module may determine, based on the contextual information, that the contextual override applies and return the configuration data, including data from the override definition, to the application.

Abstract: A core management system identifies changes to a function signature of an instruction in a core framework of a computer program, generates a static code analysis rule indicating the change to the function signature in the computer program, and distributes the rule to one or more consumer systems using the core framework with an update to the core framework.

Abstract: Embodiments described include systems and methods for using an HTML-based application integrated with an embedded browser on a client device, for trusted data transfer for instance. An HTML-based application within an embedded browser of a client device can provide access to a network application and its resources. The HTML-based application can establish a secure session for the network application between a server and the HTML-based application. The embedded browser can determine that the HTML-based application is a trusted application via application of one or more policies. With the secure session established and responsive to determining that the HTML-based application is a trusted application, the embedded browser may establish at least one virtual channel between the embedded browser and the HTML-based application. Using the at least one virtual channels, the embedded browser can transfer data between the secure session of the network application and the operating system (OS) of the client device.

Abstract: An application code is executed to generate application web page code for an application web page. An application framework is invoked according to a script in the application code to support retrieval of feature codes from a Feature as a Service (FaaS) data store and content codes from a Content as a Service (CaaS) data store. A feature code of a feature is retrieved via a corresponding Representational State Transfer (REST)ful web service from the FaaS data store. The feature code is executed to generate feature presentation code that is incorporated into the application web page code. A content code is retrieved via a corresponding RESTful web service from the CaaS data store. The content code is executed to retrieve specific content for the feature from a content data store and incorporated with the feature presentation code. The application web page code is sent to a web browser for rendering.

Abstract: A method, apparatus, and computer program product for validating a structured data object. A computer system identifies rules for validating interrelationships among data nodes. The data nodes are composable into structured data objects according to a domain specific language. The validation rules are topologically sorted according to dependency relationships declared therein. The computer system receives the structured data object, which consists of interrelated data nodes. The structured data object is traversed according to a traversal algorithm that tracks dependency relationships. Each data node is inserted into a queue according to the traversal algorithm. For each data node in the queue, a subset of the validation rules is identified. The subset is run within a context of the structured data object. Rule failure for the data node are recorded, and a failure report is generated that indicates failure results for each data node.

Abstract: Computer-implemented methods are provided for generating a data structure representing tabular information in a scanned image. Such a method can include storing image data representing a scanned image of a table, processing the image data to identify positions of characters and lines in the image, and mapping locations in the image of information cells, each containing a set of the characters, in dependence on said positions. The method can also include, for each cell, determining cell attribute values, dependent on the cell locations, for a predefined set of cell attributes, and supplying the attribute values as inputs to a machine-learning model trained to pre-classify cells as header cells or data cells in dependence on cell attribute values.

Abstract: The present disclosure provides an unsupervised exception access detection method and apparatus based on one-hot encoding mechanism. The method includes: encoding each test URL sample by using one-hot encoding mechanism, to obtain a high-dimensional vector; inputting the high-dimensional vector into a pre-built deep autoencoder network for compression and dimension reduction processing, to obtain a two-dimensional vector; performing visualization operation on the two-dimensional vectors by using a two-dimensional coordinate system, to obtain visualized test URL samples; performing a cluster analysis on all visualized test URL samples by using a K-means algorithm, to divide the test URL sample set into a first type and a second type of URL sets; comparing sample sizes of the first type and second type of URL sets, determining the URL set with a larger sample size as a normal URL set, and determining the URL set with a smaller sample size as an abnormal URL set.

Abstract: A computer-implemented method for improving performance of data processing with nullable schema information by using a data processing framework is presented. The method includes reading, by the processor, data from one or more blocks forming a column, where the data is stored in a database including the one or more blocks and determining, by the processor, whether any row in each block of the one or more blocks includes null data. The computer-implemented method further includes executing, by the data processing framework, optimized code if the block does not include null data and executing, by the data processing framework, non-optimized code if the block includes null data.

Abstract: Systems and methods are provided for transcompiling non-distributed source code for a nondistributed software program into a distributed software package for implementation on a distributed computing system. A transcompiler can identify loops within non-distributed source code written in a data-driven language. The transcompiler can generate MapReduce jobs using mapper keys based on grouping indicators associated with each of the loops. The MapReduce jobs can be linked together based on input-output connections of the loops in the non-distributed source code. Then, the transcompiler can generate a distributed software package including the generated MapReduce jobs to implement the same functionality as the non-distributed source code on the distributed computing system, thereby improving the speed of execution over very large datasets. The distributed software package can be optimized using machine learning searching algorithms.

Abstract: An RPC conversion processing system (10) that performs relaying between a first application (70) and second application (80) of different protocols. The RPC conversion processing system includes a first interface provider (20) connected to the first application and configured to provide a first interface for the first application, an RPC conversion relay function section (40), and a second interface provider (30) connected to the second application and configured to provide a second interface for the second application. The first interface provider receives a request for processing an RPC from the first application. The RPC conversion relay function section converts the RPC into an RPC of the second application and outputs the RPC of the second application to the second interface provider, thereby relaying an RPC between the first application and the second application.