Patent Application
20200164273
The present invention relates to systems and methods providing users the ability to manipulate gameplay and other features in various software applications through a set of selectable software modifications.
In some software game applications, also referred to as video games, users are able to customize the game they are playing. For example, some video games allow the user to specify what a character wears, what the character carries with them, and the abilities the character has. However, the in-game customizations allowed by modern video games are particular to each game and are pre-set by the game designer. A user who plays a first game cannot switch to playing a second game and expect that they will be able to modify the second game in the same ways that they can modify the first game. To customize the game beyond what is pre-set by the game designer, a user, outside of gameplay, must access and modify the complex software of the video game to revise relevant sections of code, which is beyond the capabilities of a typical user and, in some cases, prevented by security measures of software.
In some embodiments described herein, systems and methods provide users the ability to modify software game applications, in-game, using software modifications that are applicable across various game applications. Accordingly, in some embodiments, an in-game software editor is provided to enable unique customizations of software game applications that are not tied to a particular game. For example, the user is able to select and modify the appearance and behavior of one or more sprites in a gameplay interface through use of an overlaid editing panel. The editing panel includes icons, each associated with different types of modifications (also referred to as a glitches or filters), that, for example, adjust one or more attributes of sprites on the gameplay interface and modify code of sprites included in the graphical gameplay interface. Embodiments described herein provide an intuitive software editor that does one or more of the following: introduces users to software programming, simplifies software customization, provides universal editing functions that are applicable across different software game applications, inspires creativity, and increases variety in gameplay.
In one embodiment, an in-game video game editing method is provided. The method includes executing, by an electronic processor, a first game software application to generate a first graphical gameplay interface including a first sprite on a display, the first game software application defining the first sprite. The electronic processor receives first gameplay input from a human interface device that controls gameplay of the first game software application on the first graphical gameplay interface. The method further includes modifying the first sprite based on a selection of a predetermined modification from a plurality of selectable predetermined modifications and updating the first graphical gameplay interface to include the modified first sprite. The method further includes executing, by the electronic processor, a second game software application to generate a second graphical gameplay interface including a second sprite on the display, the second game software application defining the second sprite. The electronic processor receives second gameplay input from the human interface device that controls gameplay of the second game software application on the second graphical gameplay interface. The method further includes modifying the second sprite based on a further selection of the predetermined modification from the plurality of selectable predetermined modifications and updating the second graphical gameplay interface to include the modified second sprite.
In another embodiment, an in-game video game editing system is provided. The system includes a human interface device, a display, a memory storing a first game software application defining a first sprite and a second game software application defining a second sprite; and an electronic processor communicatively coupled to the human interface device, the display, and the memory. The electronic processor is configured to execute the first game software application to generate a first graphical gameplay interface including the first sprite on the display and to receive first gameplay input from the human interface device that controls gameplay of the first game software application on the first graphical gameplay interface. The electronic processor is further configured to modify the first sprite based on a selection of a predetermined modification from a plurality of selectable predetermined modifications and to update the first graphical gameplay interface to include the modified first sprite. The electronic processor is further configured to execute the second game software application to generate a second graphical gameplay interface including the second sprite on the display and to receive second gameplay input from the human interface device that controls gameplay of the second game software application on the second graphical gameplay interface. The electronic processor is further configured to modify the second sprite based on a further selection of the predetermined modification from the plurality of selectable predetermined modifications and to update the second graphical gameplay interface to include the modified second sprite.
In another embodiment, another in-game video game editing method is provided. The method includes executing, by an electronic processor, a game software application to generate, on a display, a graphical gameplay interface including a plurality of sprites. The electronic processor receives a gameplay input from a human interface device for controlling gameplay of the game software application on the graphical gameplay interface and generates a graphical editing panel on the graphical gameplay interface. The method further includes receiving, from the human interface device, a selection of a predetermined modification included in the graphical editing panel. The electronic processor determines a type of the predetermined modification, wherein the type indicates whether the predetermined modification includes adding a new sprite and whether the predetermined modification includes selecting a sprite of the plurality of sprites on the graphical gameplay interface. In response to the type of the predetermined modification, receiving, from the human interface device, a selection of a sprite of the plurality of sprites on the graphical gameplay interface. The electronic processor further adds a block of code to the selected sprite based on the predetermined modification to generate a modified sprite, and executes the block of code to provide the modified sprite on the graphical gameplay interface.
Other aspects of the invention will become apparent by consideration of the detailed description and accompanying drawings.
One or more embodiments are described and illustrated in the following description and accompanying drawings. These embodiments are not limited to the specific details provided herein and may be modified in various ways. Furthermore, other embodiments may exist that are not described herein. Also, the functionality described herein as being performed by one component may be performed by multiple components in a distributed manner. Likewise, functionality performed by multiple components may be consolidated and performed by a single component. Similarly, a component described as performing particular functionality may also perform additional functionality not described herein. For example, a device or structure that is “configured” in a certain way is configured in at least that way, but may also be configured in ways that are not listed. Furthermore, some embodiments described herein may include one or more electronic processors configured to perform the described functionality by executing instructions stored in non-transitory, computer-readable medium. Similarly, embodiments described herein may be implemented as non-transitory, computer-readable medium storing instructions executable by one or more electronic processors to perform the described functionality. As used in the present application, “non-transitory computer-readable medium” comprises all computer-readable media but does not consist of a transitory, propagating signal. Accordingly, non-transitory computer-readable medium may include, for example, a hard disk, a CD-ROM, an optical storage device, a magnetic storage device, a ROM (Read Only Memory), a RAM (Random Access Memory), register memory, a processor cache, or any combination thereof.
In addition, the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting. For example, the use of “including,” “containing,” “comprising,” “having,” and variations thereof herein is meant to encompass the items listed thereafter and equivalents thereof as well as additional items. The terms “connected” and “coupled” are used broadly and encompass both direct and indirect connecting and coupling. Further, “connected” and “coupled” are not restricted to physical or mechanical connections or couplings and can include electrical connections or couplings, whether direct or indirect. In addition, electronic communications and notifications may be performed using wired connections, wireless connections, or a combination thereof and may be transmitted directly or through one or more intermediary devices over various types of networks, communication channels, and connections. Moreover, relational terms such as first and second, top and bottom, and the like may be used herein solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions.
The game system 105 may be communicatively connected to the display 115, microphone 120, controller 125, camera 130, and speaker 132 via various wired or wireless connections. For example, in some embodiments, the game system 105 is directly coupled via a dedicated wire to each of the above-listed components of the game system 105. In other embodiments, the game system 105 is communicatively coupled to one or more of the components via a wireless connection.
The game system 105 is configured to send information to and receive information from a remote server 135 via a network 140, which may be wired, wireless, or a combination thereof. For example, the information that may be sent from the remote server 135 and received by the game system 105 includes a games library 145 and a glitch-filter library 150. Although the remote server 135 is illustrated as one server, the remote server 135 may include a plurality of servers. Thus, the games library 145 and the glitch-filter library 150, while illustrated as being stored on one server, may be distributed amongst a plurality of servers making up the remote server 135.
The memory 205 includes an operating system 220, a glitch-filter library 225, and a games library 230. The games library 230 contains a plurality of game software applications including a first game software application 235, a second game software application 240, and additional game software applications 241. The first game software application 235 has a first plurality of sprites 242 including a first sprite 245. The second game software application 240 has a second plurality of sprites 247 including a second sprite 250. A sprite is an object that is displayed within a game play interface and that has a plurality of blocks of code. For example, a sprite may be a two dimensional bitmap (such as a JPEG) that is integrated into the graphical gameplay interface. A block of code of the plurality of blocks of code defines, for example, the appearance (physical attributes) of the sprite, behavior of the sprite, or both. For example, a block of code that defines the behavior of the sprite may cause the sprite to move upwards on the game play interface until the sprite touches another sprite on the game play interface. A block of code defining the sprite may also define a physical attribute of the sprite such as the color of the sprite. The glitch-filter library 225 includes glitches, filters, or both, which, as described in further detail below, are configured to provide a variety of modifications to sprites within a game software application.
The device input/output interface 215 is configured to enable the electronic processor 200 to communicate with the human interface devices 110 including the display 115, the microphone 120, the controller 125, the camera 130, and the speaker 132. The network input/output interface 210 is configured to enable the electronic processor 200 to communicate with the remote server 135 via the network 140. For example, the interfaces 210 and 215 may include one or more of driver circuitry, terminal connections, wireless transceivers, and signal processing circuits. The electronic processor 200 retrieves up-to-date versions of game software applications from the games library 145 on the remote server 135, such as one or more of the applications shown in
In some embodiments, the electronic processor 200 may receive input that commands the electronic processor 200 to associate an action performed by a user or a sound made by the user with a gameplay input button or editing input button on the controller 125. For example, the electronic processor 200 may receive input declaring that the electronic processor 200 should associate receiving an indication of a hand-waving motion from the camera 130 with receiving input from one of the gameplay input buttons 500 on the controller 125. Thereafter, when the electronic processor 200 receives an indication of a hand-waving motion from the camera 130, the electronic processor 200 behaves as it would if it received an actuation of a gameplay input button. In another example, the electronic processor 200 may receive input declaring that the electronic processor 200 should associate receiving an indication of a whistle from the microphone 120 with receiving input from one of the gameplay input buttons 500 on the controller 125. Thereafter, when the electronic processor 200 receives an indication of a whistle from the microphone 120, the electronic processor 200 behaves as if it received an actuation of a gameplay input button.
During execution of the game software application, modification input or quit game input may be received at one or more of the human interface devices 110, such as the controller 125, from a user. The human interface devices 110 provide the modification input or quit game input that was received to the electronic processor 200. The modification input may be a request to add a glitch (upon actuation of the glitch button 510), add a filter (upon actuation of the filter button 515), or modify code (upon actuation of the code button 520). The electronic processor 200 receives the modification input and proceeds to block 620 to add a glitch, to block 625 to add a filter, or to block 630 to modify code, in accordance with the request received. For example, in block 620, the electronic processor 200 displays a graphical editing panel with the glitches the user can select, receives user input, via the human interface devices 110 specifying a glitch, and applies the glitch specified. Similarly, in block 625, the electronic processor 200 displays the graphical editing panel with the filters the user can select, receives user input, via the human interface devices 110 specifying a filter, and applies the filter specified. Similarly, in block 630, the electronic processor 200 displays a code editing interface, receives user code editing input, via the human interface devices 110, as described below with respect to
In response to quit game input, the electronic processor 200 proceeds from block 610 to block 650. If the game software application has not been modified (e.g., via blocks 615, 620, 625, or 630), the electronic processor 200 returns to the home screen 300 in block 600. If, however, the game software application has been modified, the electronic processor 200 prompts the user (e.g., on the display 115) to indicate whether to save the modified game software application. In response to receipt of an indication not to save, the electronic processor 200 returns to the home screen 300 in block 600. In response to receipt of a request to save the game, the electronic processor 200 uploads the modified game software application to the games library 145 on remote server 135. In turn, the electronic processor 200 (and the electronic processors of other games systems 105 coupled to the remote server 135) will be able to retrieve the modified game software application for display on and selection from the ribbon 305 in the home screen 300.
Upon receiving input from the user indicating the user's desire to edit the game (such as pressing one of the editing buttons 505 of the controller 125), and a selection of a predetermined modification (a glitch or a filter), the electronic processor 200 modifies the first sprite 245 based on the selected predetermined modification (block 725). Various examples of predetermined modifications are described below in further detail. After the predetermined modification is applied, the electronic processor 200 updates the first graphical gameplay interface to include a modified first sprite 245 (block 730).
In some embodiments, during the course of executing the first game software application, block 725 is repeated several times such that further selected predetermined modifications are applied to various sprites of the first game software application 235 in response to further input provided by the human interface devices 110.
The steps described above may be applied to a plurality of game software applications and a plurality of sprites. For example, in some embodiments, the electronic processor 200 executes the second game software application 240 stored in the memory 205 of the game system 105 to generate a second graphical gameplay interface (block 735). The second graphical gameplay interface includes the second sprite 250. The second game software application 240 defines the second sprite 250. The electronic processor 200 receives a second gameplay input from the human interface devices 110 (block 740). The second gameplay input controls the gameplay on the second graphical gameplay interface. In response to receiving the second gameplay input, the electronic processor 200 moves the second sprite 250 on the second graphical gameplay interface. An example of gameplay input is pressing a button to move the second sprite 250 to jump or turn on the second graphical gameplay interface. Upon receiving input from the user indicating the user's desire to edit the game (such as pressing one of the editing buttons 505 of the controller 125) and a selection of the predetermined modification (which may be the same predetermined modification as the predetermined modification selected for the first game software application), the electronic processor 200 modifies the second sprite 250 based the predetermined modification (block 755) and updates the second graphical gameplay interface to include the modified second sprite 250 (block 760).
The above described method may be applied to any of the sprites included in the first plurality of sprites 242 of the first game software application 235 or any of the sprites included in the second plurality of sprites 247 of the second game software application 240. For example, a third sprite displayed on the first graphical gameplay interface may be modified based on editing input from a user and the first graphical gameplay interface is then updated to include the modified third sprite.
In some embodiments, depending on the modification that was made to, for example, the first sprite 245, the behavior of the modified first sprite 245 will affect other sprites (for example, the third sprite) on the first graphical gameplay interface. For example, if the first sprite 245 is modified in a way that gives the first sprite 245 a virtual shooting ability (i.e., the ability to emit a virtual projectile) and the third sprite touches the virtual projectile (i.e., on the graphical gameplay interface, the projectile “hits” the third sprite) the third attribute of the third sprite may be modified in a manner that is dependent on the type of virtual projectile that the first sprite 245 emitted. Examples of types of virtual projectiles are given below in Table 1. In another example, an attribute of the third sprite is modified when the third sprite touches the modified first sprite 245, and the third sprite displayed on the first graphical gameplay interface is then updated with the modified third attribute. Further, in some embodiments, the selected predetermined modification itself modifies one or more other sprites on the graphical gameplay interface. For example, the predetermined modification may specify how the other sprites are to interact with the first sprite 245 or projectiles emitted from the first sprite 245.
Referring momentarily to
In
By injecting a block of glitch code into a sprite, as described with respect to
Returning now to
The code editing interface 1000 displays the software code of one or more glitches and filters of a game software application in the code panel 1005. For example, the code panel 1005 may display glitch code and filter code of the first game software application 235. In some embodiments, (such as the embodiment illustrated in
The code editing interface 1000 also includes an editing panel 1025 including editing function icons, which may be graphical, textual, or both. The editing function icons are each associated with an editing function, such as choosing a glitch to edit and selecting blocks of code to add to the code of a glitch or filter. For example, in response to selection of a first editing function icon, a list of selectable glitches may be displayed. In response to a user selection of a glitch, the glitch code associated with the selected glitch is displayed in the code panel 1005. The glitch code of each glitch is made up of a plurality of blocks of code that define a portion of the physical attributes and the behaviors of a sprite that a glitch is applied to. For example, the glitch code is displayed in the code panel 1005 and includes blocks of code 1035, 1040 that define a portion of the physical attributes and behaviors of a sprite that the glitch is applied to. The code editing interface 1000 is configured to receive modifications to the code blocks 1035, 1040 based on user input via the human interface devices 110. The user may directly modify the code, for example, by typing to delete, add, or replace code, using other graphical inputs (e.g., using graphical arrows or scroll bars), or dragging and dropping graphical code segments that may be combined to form code blocks to and from the editing panel 1025 and the glitch code in the code panel 1005. A menu 1041 (located above the code panel 1005 in the illustrated embodiment) highlights an icon which signifies to the user which sprite the code will be added to when the glitch is applied to the game software application. For example, when an icon 1042 is highlighted, or in some way distinguished, the code displayed in the code panel 1005 is code that will be added to a selected sprite (the protagonist) upon applying the glitch. When the icon 1043 is highlighted, or in some way distinguished, the code displayed in the code panel 1005 is code that will be added to sprites included in a game software application other than a selected sprite upon applying the glitch. When the icon 1044 is highlighted, or in some way distinguished, the code displayed in the code panel 1005 is code that will be added to a new sprite that is added upon applying the glitch.
In the embodiment illustrated in
In some embodiments, some of the functionality of the system 100 described herein employs the Scratch™ programming language developed at the Massachusetts Institute of Technology (“MIT”) and some of the functionality of the system 100 described herein employs JavaScript™. In some embodiments, other programming languages are used.
When the electronic processor 200 receives a selection of a glitch icon, the glitch associated with the glitch icon is applied by the electronic processor 200 to one or more sprites on the graphical gameplay interface 400. Applying a glitch to one or more sprites includes modifying the code of the one or more sprites. In one example, upon receiving a selection of a glitch icon on the glitch menu 1105 and the sprite 405, the electronic processor 200 retrieves one or more blocks of code associated with the selected glitch and modifies the sprite 405 by adding the block of code to the sprite (see, e.g., blocks 815, 825, and 830 of
The electronic processor 200 of the game system 105 is also configured to apply a glitch to sprites in a graphical gameplay interface that are not selected by a user or newly added to a graphical gameplay interface. For example, in the graphical gameplay interface 400, the glitch may be applied to other sprites including a base and bumpers. As described above in
When the electronic processor 200 is executing the associated game software application having the glitch, sprites in a graphical gameplay interface are displayed and controlled according to the applied glitch. For example, glitches can provide the sprite 405 with the a virtual flying ability, provide the sprite 405 a virtual gravitational pull, prevent the virtual movement of the previously mobile sprite 405, enable the virtual movement of the previously immobile sprite 405, provide the sprite 405 with a virtual shooting ability, provide a virtual attractive force between the sprite 405 and a virtual graphical object displayed by the graphical gameplay interface 400, and change the visual representation of the sprite 405. See Table 1 for a list of example glitches and further description.
In the illustrated embodiment, a menu 1115 displays the filters that are available for user selection via the human interface devices 110. A filter is similar to a glitch in that it also, when executed by the game system 105, modifies one or more attributes or code blocks of a sprite included in a game software application (for example, the first game software application 235) of the games library 230. However, a filter modifies the code of a plurality of sprites, or all sprites, in the game software application, adds a plurality of new sprites to the game software application each having the same block of code, or both. Accordingly, while a glitch is generally a sprite-centric modification, a filter is a game-wide modification. In some embodiments, a list of sprites is displayed before application of the filter to enable user selection of one or more particular sprites of the game software application that should not be modified when the filter is applied.
In some embodiments, rather than providing a glitch menu that is spatially or temporally separated from a filter menu, a combined glitch-filter menu with both selectable glitch icons and selectable filter icons is provided on the graphical gameplay interface 400.
In response to selection of a glitch or filter (see, e.g., block 810 of
On the right side of the graphical editing panel 1100 is a parameter glitch menu 1125. The parameter glitch menu 1125 lists a plurality of physical attributes of a sprite that may be adjusted according to user input for a selected glitch. With reference to the flow chart of
A sprite is selected to receive a glitch in a variety ways. For example, a cursor 1130 may be provided on the graphical gameplay interface 400 in the glitch mode (see, e.g., block 825 of
Table 1 (below) describes examples of the ways that glitches modify sprites in a game software application.
In another example of a superpower-type glitch, a sound-control or visual-control glitch modifies the code of a sprite to redefine the inputs used to control the sprite. For example, initially, a sprite may be configured through code to virtually jump in response to a first button press on the controller 125. However, the sound-control glitch may modify the code of the sprite such that the sprite virtually jumps on the interface 400 in response to a particular sound captured via the microphone 120 or particular motion captured via the camera 130. For example, the electronic processor 200 is configured to receive audio data via the microphone 120, compare the audio data to a volume threshold and, when the volume threshold is exceeded, consider the captured audio data as a user gameplay input that causes the sprite to virtually jump. Thus, a user may shout, whistle, or clap, above a certain threshold, to cause the sprite to jump, or perform another action. In some embodiments, other audio analysis techniques are used (e.g., common speed recognition techniques) to detect particular words (e.g., “jump” or “shoot”) from captured audio data that are associated with a control action by an implemented glitch. In response to detection of the particular words, the electronic processor 200 controls the sprite according to the control action defined in the code of the sprite, as modified by the glitch. Similarly, the electronic processor 200 is configured to receive image data via the camera 130, analyze the data using common image processing techniques to detect certain motions (e.g., a hand wave), and, when the certain motions are detected, consider the detected motion as a user gameplay input that causes the sprite to virtually jump or take another action defined in the code of the sprite, as modified by the glitch.
In some embodiments, the glitch-filter library 225 includes a sound swap glitch that associates a sound that the electronic processor 200 receives from a human interface device 110 (for example, the microphone 120) with an event on a graphical gameplay interface. As one example, in the first game software application 235, a sound is emitted from a human interface device 110 (for example, the speaker 132) when the first sprite 245 (the ball) touches another sprite in the graphical gameplay interface 400. Then, when the sound swap glitch is selected and a sound is received via the microphone 120, the electronic processor 200 replaces the sound currently emitted when the first sprite 245 touches another sprite on the graphical gameplay interface 400 with the sound received from the microphone 120. In some embodiments, the electronic processor 200 manipulates (e.g., crops, compresses, extends, or loops) the sound it receives from the microphone 120 to match a duration of the captured sound to that of the sound it is replacing.
One or more of the above glitches may also be implemented as a filter and applied to one or more sprites within a graphical gameplay interface.
An example of an application of a filter is illustrated in
Some filters are designed to add elements of a first game software application to a second game software application currently on the graphical gameplay interface 400. For example, the electronic processor 200 may receive a selection of a filter (such as the pinballize filter 1905 selected in
Further, multiple filters may be applied to the game software application. For example, in
In some embodiments, the application of a glitch to a game software application provides the ability to transfer code from one sprite to another sprite. These glitches may be referred to as code swap glitches and may further be categorized into one of the aforementioned types of glitches (e.g., edit, magic, block, superpower, or cannon). Depending on the particular code swap glitch, the sprites selected for the code swap varies, the technique used to select to sprites to swap code varies, the portion of code swapped varies, and whether the code swap is unidirectional or bidirectional varies. Below are examples of code swap glitches. The code transfers described for the various code swap glitches are implemented by the electronic processor 200.
In one example, a code swap glitch selected from the object-type glitches of the menu 1305 creates a new sprite on the screen that, when encountered by a first sprite (e.g., the sprites “touch” on the interface 400), receives code from the encountered sprite or is marked as a donor sprite. Then, when a second sprite encounters the new sprite, the code from the donor sprite is transferred to the second (recipient) sprite to modify the second sprite. The particular code transferred may modify various aspects of a sprite, for example, appearance (e.g., size or color) or behavior (e.g., speed, flying ability, jumping ability). In some embodiments, the code swap is bidirectional and code from the second sprite is also provided to the first sprite that replaces the code provided by the first sprite to the second sprite.
In another example, a code swap glitch selected from the edit-type glitches of the menu 1405 transfers code from a first selected sprite to a second selected sprite. The first and second selected sprites are, for example, selected via a cursor controlled by the controller 125 in response to user input. Again, the particular code transferred may modify various aspects of a sprite and the code swap may be bidirectional.
In another example, a code swap glitch selected from the cannon-type glitches of the menu 1605 modifies the code of a first (donor) sprite to provide a virtual shooting ability (see, e.g.,
In another example, a code swap glitch selected from the magic-type glitches of the menu 1705 may cause a sprite periodically transfers code from itself to another sprite on the graphical gameplay interface, such as the nearest sprite or a sprite previously selected as a recipient sprite. Again, the particular code transferred may modify various aspects of a sprite and the code swap may be bidirectional. Further, in another example, the transfer of code may be periodically reversed such that the sprites revert to their pre-modified versions, and then back to their modified versions.
In another example, a code swap glitch selected from the superpower-type glitches of the menu 1505 may cause a sprite to have the capability to transfer code from itself to another sprite on the graphical gameplay interface, such as the nearest sprite or a sprite previously selected as a recipient sprite, in response to an input at the controller 125. Again, the particular code transferred may modify various aspects of a sprite and the code swap may be bidirectional. Further, in another example, the transfer of code may be repeated upon each repeated input at the controller 125 (e.g., each press of a particular button) such that the code may be transferred from the sprite to a different recipient sprite upon each button press.
The glitches and filters listed in the above tables and described herein are merely examples of glitches and filters. In some embodiments, additional or fewer glitches and filters are provided by the game system 105.
It should be noted that while the above functionality is described as being performed in relation to video games, glitches and filters may be applied to other forms of media such as images, video, and animations (e.g., cartoons, animated comics, and the like).
Various features, advantages, and embodiments are set forth in the following claims.
This application is a continuation application of U.S. patent application Ser. No. 15/958,557, filed on Apr. 20, 2018, the entire contents of which are hereby incorporated by reference.
| Number | Date | Country | |
|---|---|---|---|
| Parent | 15958557 | Apr 2018 | US |
| Child | 16774673 | US |
