text
stringlengths 1
22.8M
|
|---|
New Dreams Ltd. is the third studio album by American electronic musician Vektroid under the alias Laserdisc Visions released on July 1, 2011. The album is an early example of the genre vaporwave.
Release
The album was released through the independent label Beer on the Rug and Vektroid's own label PrismCorp. The album has good reviews and is one of Vektroid's more popular releases. A digital reissue of the album in 2012 included six bonus tracks, but removed the reverberated Japanese commercials that played for the length of the original release, leaving only the original and sample-based compositions.
Track listing
See also
2011 in music
Ambient music
References
External links
Bandcamp
WhoSampled
Vektroid albums
2011 albums
Vaporwave albums
|
The Eakins Press Foundation is an American publishing house based in New York established by Leslie George Katz in 1966 and named after the painter Thomas Eakins. Since its founding in 1966, the Eakins Press Foundation has published some of the classic volumes on American art and photography, including Lee Friedlander’s The American Monument, Walker Evans’s Message from the Interior, and Lincoln Kirstein’s definitive monograph on Elie Nadelman.
The Eakins Press Foundation was recognized as a 501(c)(3) charitable foundation in 1974.
Details
Katz (1918–97), a former Black Mountain College student, established the press from the proceeds of a sale of his father's collection of Thomas Eakins paintings to Joseph Hirshhorn; to this day they comprise the nucleus of the Eakins Collection at the Hirshhorn Museum and Sculpture Garden in Washington, D.C.
The initial releases were a replica of the original 1855 edition of Leaves of Grass, the collection of twelve poems written by Walt Whitman that he had published himself; and Message From the Interior a collection of photographs by Walker Evans, who was best known for his work for the Farm Security Administration that captured the effects of the Great Depression. Both published in 1966, they represented the beginning of the Eakins Press imprint. For the next three decades, until his death in 1997, Katz published 56 books that were described by The New York Times as being "notable for their meticulous, elegant design", including works of photography, poetry, sculpture and the New York City Ballet. It published Lee Friedlander’s The American Monument, and Lincoln Kirstein’s definitive monograph on Elie Nadelman.
A January 1993 show at the Zabriskie Gallery in New York City featured selections of 14 works published by the Eakins Press Foundation, along with samples of the art produced by the artists highlighted in the books.
Since Katz's death in 1997, the Eakins Press Foundation continues to produce its "invaluable explorations of the American imagination" with publications including Circus: The Photographs of Frederick W. Glasier in 2009; Jed Perl's collection of essays on art and culture, Magicians & Charlatans in 2013; and 'O, Write My Name': American Portraits, Harlem Heroes (2015), a collection of fifty portraits taken by Carl Van Vechten of extraordinary individuals from the Harlem Renaissance. The current Director of the Eakins Press Foundation is Peter Kayafas.
References
External links
Eakins Press Foundation
Book publishing companies of the United States
Publishing companies established in 1966
1966 establishments in New York (state)
|
```javascript
"use\x20strict";
```
|
Decent Work for Decent Pay is a DJ mix compilation album by Diplo. It was released on Big Dada on January 26, 2009.
Critical reception
At Metacritic, which assigns a weighted average score out of 100 to reviews from mainstream critics, Decent Work for Decent Pay received an average score of 60% based on 10 reviews, indicating "mixed or average reviews".
C. T. Heaney of PopMatters gave the album 5 stars out of 10, saying, "it goes in so many different directions (some expertly, some unimpressively) that it's hard to tell what, exactly, Diplo is trying to accomplish by putting it all here in one place."
Track listing
Charts
References
External links
2009 compilation albums
Diplo albums
Big Dada albums
Albums produced by Diplo
|
Fear play is any sexual activity involving the use of fear to create sexual arousal. Unlike masochistic tendencies, fear play does not offer the subject pleasure or arousal through a rush of endorphins, but rather a terrified mental state which triggers a release of adrenaline. Some have likened its role to that of horror movies, in providing a harmless outlet in which to feel frightened.
Definition
Fear play is typically considered edge play, a category of BDSM-related activities with high physical or psychological risk. While limits are usually set out in sexplay, they may be pushed or ignored in some edge play scenes to heighten sexual arousal as the subject becomes excited by the feeling of helplessness. Asphyxiation and castration play are common within edge play sub-sections of BDSM.
Examples
Some types of fear play may take advantage of a person's doubts, such as abandonment or humiliation. Others are more physically based. Medical play, knife play, or kidnappings may include a psychological aspect of fear, but it may be the physical activity that causes the emotion.
References
BDSM terminology
Fear
|
```ruby
# frozen_string_literal: true
module Admin
class TagsController < BaseController
before_action :set_tag, except: [:index]
PER_PAGE = 20
def index
authorize :tag, :index?
@tags = filtered_tags.page(params[:page]).per(PER_PAGE)
end
def show
authorize @tag, :show?
@time_period = (6.days.ago.to_date...Time.now.utc.to_date)
end
def update
authorize @tag, :update?
if @tag.update(tag_params.merge(reviewed_at: Time.now.utc))
redirect_to admin_tag_path(@tag.id), notice: I18n.t('admin.tags.updated_msg')
else
@time_period = (6.days.ago.to_date...Time.now.utc.to_date)
render :show
end
end
private
def set_tag
@tag = Tag.find(params[:id])
end
def tag_params
params.require(:tag).permit(:name, :display_name, :trendable, :usable, :listable)
end
def filtered_tags
TagFilter.new(filter_params.with_defaults(order: 'newest')).results
end
def filter_params
params.slice(:page, *TagFilter::KEYS).permit(:page, *TagFilter::KEYS)
end
end
end
```
|
The Goddess () is a 1934 Chinese silent film released by the Lianhua Film Company (United Photoplay). The film tells the story of an unnamed woman, who lives as a streetwalker by night and devoted mother by day in order to get her young son an education amid social injustice in the streets of Shanghai, China. It stars Ruan Lingyu in one of her final roles, and was directed by Wu Yonggang. Lo Ming Yau produced the film and Hong Weilie was the cinematographer.
The public responded with enthusiasm, largely due to Ruan Lingyu's popularity in Shanghai in the early 1930s. Four years after the original release of Goddess, Yonggang Wu remade the film as Yanzhi Lei) with changes made to the cast, the setting, and parts of the storyline. After Stanley Kwan's revival of Ruan Lingyu's story through the biopic Center Stage (1991) starring Maggie Cheung as Ruan, widespread public interest in the Chinese classic cinema was reinvigorated .
Today, Goddess is one of the best-known films of China's cinematic golden age, and has been named as one of China's top 100 films by the Hong Kong Film Awards in 2005.
Cast
Ruan Lingyu as the "Goddess", a loving mother who is forced into prostitution in order to provide for her young son.
Zhang Zhizhi as "Boss" Zhang, a thug who exploits the Goddess and acts as her pimp after he offers her protection from the police.
Lai Hang as the Goddess's son, who faces discrimination as he grows up because of his mother's occupation.
Li Junpan as the Principal, a well-meaning older man who stands up for the Goddess' son, after the members of the school board discovers that his mother is a prostitute and want to expel him. The old principal also represents the voice of the Director Wu Yonggang.
Plot
An unnamed single mother (Ruan Lingyu) works as a prostitute to support herself and her baby son in 1930s Shanghai. One night, fleeing from a police sweep, she runs into the room of a thug called, "the Boss", (Zhang Zhizhi) who then forces her to have sex with him in exchange for hiding her from the police.
She agrees and later, the Boss, with two of his henchmen, tracks her down and shows up at her place and claims her as his own private property. From then on, he steals all her earnings to finance his gambling habit. The mother attempts to flee, to avoid him and find a respectable job, by moving to a new apartment. However, after pawning her jewelry to buy a toy for her son, she returns home to find out that the Boss tracked her down again. He threatens her, frightening her by claiming to have sold her son and the mother decides to submit to him again to retrieve her son. While living with the thug, she secretly stashes her nights’ earnings behind a hole in the wall, in order to provide her son with an education.
After years, she enrolls her son in a private school. But soon after, other kids at school begin to bully him and call him a "bastard" and the parents also learn that the boy's mother is a prostitute, which leads them to send reproachful letters to the school, demanding the school to expel the boy, complaining that they cannot allow their children to study together with a child from mother with a disreputable profession. Without a choice, the principal pays a visit to the goddess’ home to investigate the accusations of her profession, but the rumors prove to be true. As he sets his mind on expelling the boy, he is swayed by the mother's genuine love for her son and her heartfelt cries, questioning why her son cannot receive what is best for him. Realizing his mistake, the principal goes back to the school to convince other members of the school committee but they do not listen to him. Upon his failure, the principal resigns from his position and the boy's expulsion goes through.
Subsequently, the mother plans to move to a new place with her son where nobody will recognize who they are. When she tries to take out her savings from the hole in the wall, she realizes that the thug has stolen the money to support his gambling habits. When she asks him to return her money, he mocks her and informs that he has already spent it. In a moment of anger, she inadvertently kills the thug by smashing a bottle on his head.
In the end, the mother is convicted of the murder of the thug, the Boss, and sentenced to 12 years in jail. When the school principal reads of this news in a newspaper, he visits her behind prison bars and promises her that he would adopt her son from the orphanage and raise him well, providing a good education. Worried for her son's future and not wanting him to be burdened with his mother's dark history, she asks the principal to tell her son that his mother is dead. After the principal leaves, the young mother smiles as she envisions a bright future for her son, but her smile quickly fades away as she comes back to the cold reality of her life in the prison cell.
Title
The film's title contains several layers of meaning. The word "goddess" is meaningful in that it represents the dual identities of the main character. During the day, the word refers the character as a divine "goddess," a loving mother and guardian for her son, while at night, it refers to her occupation; the Chinese term shennü also serves as an old euphemism for prostitute. At the time of the film's release, this euphemism was particularly relevant as Shanghai was believed to be home to 100,000 women working as prostitutes. Wu's use of the euphemism portrays his views of seeing beyond the stereotype of the fallen women and calls attention to the themes of class struggle and social inequality through the complex character of Ruan Lingyu, who is both victimized and empowered at times. Although she faces the prejudice of the society, she continuously fights against social pressure and attempts to seek justice in the system.
The Goddess in Historical Shanghai
In The Goddess, Ruan appears in front of the camera wearing a cheongsam (also called a qipao), a popular style worn by women since the 1920s China. By the 1930s, qipao became the exemplary dress for modern women in urban Shanghai. Well-to-do women, courtesans, dance hostesses, actresses, girl students, and female workers almost all accepted the characteristic style of qipao.
They dressed in qipao along with short bob or permed hair, stockings, high heels, and makeup not so different as seen on the Western flappers. In this sense, Qipao represents the blend of Chinese culture and Western colonization and reflects Shanghai's weakened state. Qipao are also published in pictorial magazines, fashion designs enriched clothing styles. The fetish for appearance and fashion occurred in the cinema together with the female-featured advertisement calendar posters (yuefenpai 月份牌).
As early examples of Chinese commercial advertising, calendar posters exclusively portray women, many wearing Qipao, as the conveyor of modern marketing messages. They include pictures of women seated with crossed legs, a specific bodily posture that, both in China and in the West, can be read both as a signifier of modernity and as a possible reminder of sexual availability. Calendar posters contributed to create a hybrid format of gender representation where women are portrayed simultaneously as both subject and object of market and sexual consumption, and more precisely where "the boundaries of subject and object, active and passive, owner and owned, unique and general, break down in an endless reflexive interplay of consumer and consumed.
Qipao, as a style of the commodified women on the calendar posters reflects a society which objectified female bodies as a source of pleasure and turned them into tradable commodities which led to the rise of prostitution in Shanghai. Based on the data collected from the sociologist Gamble: In 1917, Shanghai had the highest population of prostitutes compared to other cities, such as London, Berlin and Beijing. Records show that in 1935, there was 1 woman out of 9 - 15 female adults who resorted to prostitution in order to make a living. These numbers are the reason why Wu chose Shanghai as the Goddess’ background, to depict Shanghai's submission to foreign forces and the fallen women of Shanghai. On the other hand, prostitutes, as the visual harbinger of Chinese modernity became the negative side of this metropolitan city, as their roles took on meanings of the "victimized" and the "disorderly."
In this film, Ruan played a prostitute, standing on the night street with her long qipao. However, she was not fashioned as sexy in the traditional sense. While the film tells a story about a prostitute, it did not focus on the "erotic implications" of prostitution, not to mention the connection with moral decline. Instead, it focuses on the suffering of Ruan's character from the prejudice of the education system, the humiliation from neighbours and the abuses of the thug. The temporary status of prostitute and implication of qipao together depict the suffering of these fallen women as characterized by Ruan's character.
The Practice of Self-Censorship
During the time period revolving around the goddess, a large fraction of Shanghai's female population had been designated as prostitutes—one-thirteenth of the female population. Having spent his time observing these "street walkers" and the fact that much of Wu Yonggang's early experience in cinema education revolved around the fallen women genre. Wu Yonggang had initially wished to write a screenplay to draw sympathy for them.
Despite Wu's wishes to show more of the realities of the women in Shanghai, he was forced to undergo self-censorship in order to navigate the diffuse and pervasive anxieties about ideology, politics and market confronting China's filmmakers in 1934. This is shown by Wu Yonggang response to contemporary critics, "‘When I first set out to write about the goddesses, I wished to show more of their real lives, but circumstances would not permit me to do so."
The circumstances that he refers to were the strict conservative restrictions and state surveillance in place by China's Kuomintang (KMT) Nationalist Party during the film's production in October and November 1934. When the KMT came to power, they set up the "Film Censorship Law" in 1930, and the Film Censorship committee (FCC) in 1931.
In the 1930s New Life Movement, film makers were encouraged to promote Confucian values, along with ideals of self-sacrifice and discipline in everyday life. Films would have to present their scripts to the FCC to ensure the upholding of New Life Movement values. The New Life Movement also emphasized the censoring of illicit scenes. The female lead of Goddess is a prostitute, but there are never any illicit scenes, and are implied instead (the Goddess’ child). Despite the lack of evidence which pointed to any formal orders requesting changes to Goddess, Wu may still have felt the governmental pressure, as reported by Lianhua's weekly newsletter that New Life organizational committee members, as well as high-ranking government ministers like Chen Gongbo, had paid several visits to the set half-way through the shooting of the Goddess.
The Confucian Convention: Motherhood in a Patriarchal Society
This film contains several themes alluding to certain ideas that had been present in China. In a short essay published before the film's release in 1934, Wu writes,"When starting to write the script, I wanted to focus more on ['the prostitutes’] actual life experiences. But my circumstances made this impossible. To hide this weakness, I shifted to maternal love while consigning prostitution to the background by depicting an illegal prostitute struggling between two lives for the sake of her child. I used an exploitative thug to propel the plot. I also put words of justice into the mouth of an upright school headmaster, letting him expose the social cause of prostitution. I did not offer a solution to the problem."He intentionally used motherhood as an entry point for a more gritty examination of the conditions for prostitutes in Shanghai in the 1930s.
While this film is reminiscent of the genre conventions seen in the movies containing "fallen woman" figure, it also draws on the questions of motherhood at the front and centre. The film starts with an Art Deco image in the back, with the title superimposed on this image. This image portrays a naked woman with her hands tied behind her back, leaning forward over the naked infant. This portrayal of a woman leaning over the child seems to recall the theme of motherhood to the viewers’ minds. This image reappears as the background for later intertitles, signifying the importance of the motherhood as a theme in this film. "Maternal melodramas", in which mothers sacrifice themselves for their children was a Hollywood staple since the 1920s and China had a similar motivation for this theme; Confucian convention taught women to be a "virtuous wife and good mother" (xianqi linangmu). This model of womanhood was revived by China's Nationalist government which launched its campaign, "New Life Movement" in February 1934.
On the top of this conservative model, another long-standing model of idealized womanhood seems to be at work in this film, and that is the legend of "Mencius's mother." The famous story named "Three Moves", in which Mencius's mother strives to keep her son away from bad influences, explains that Mencius's mother decided to move when she noticed that Mencius started to imitate the actions of the funeral director while they were living near a cemetery and when they moved to a place which was near a marketplace, her son began to imitate the loud voice of salespeople. Therefore, Mencius's mother decided to move to a place which was close to a school. Finally, Mencius began to imitate the students and teachers working on their study.
The film also reflects a strong sense of patriarchy in the way that the problem the mother is facing is resolved. The film portrays the elderly principal, who is a man, stepping in to resolve the dilemma for the mother. He stands up for her son when the school board tries to expel the son. Facing directly the camera, he says, "It's true the child's mother is a streetwalker, but this is due to broader social problems ... Education is our responsibility, and we must rescue this child from adversity." The son is still expelled and the mother ends up in a prison cell, and when it seems there is no hope for the powerless mother, the principal reappears to provide the ultimate solution to her; he offers to become a surrogate father to her son and raise him himself. Film historians have argued that this conclusion and narrative leave the patriarchal system unchanged and assert the primacy of male agency, where the male with a position of respectability and authority tries to correct the wrong and turns into a savior, intervening in the victimized female's situation to offer the ultimate solution to the problem. While one could say that this film is reflecting the reality Chinese people during that particular time experienced in everyday life, it also seems to act as an agency to reinforce the central ideas of patriarchists; the female mother is vulnerable and in need of help from the male principal, who is able to resolve the problems for her.
Hollywood Influence
Many early Shanghai-produced films were heavily influenced by Hollywood, a characteristic commonly seen in the filmography of the Lianhua Film Company. Goddess remains one of their most well-known films, and exhibits some of the camera techniques characteristic to Hollywood that can also be identified as part of the Lianhua Film style. Through the use of intertitles, lighting and distinctive close up shots of the protagonist's face, Cinematographer Hong Weilie humanizes the Goddess, creating a strong emotional connection between her character and the audience.
More than just being influenced by cinematic techniques originating in Hollywood, Goddess also borrows generic conventions, particularly from the "fallen woman" films popularized in the 1920s and 30s like Stella Dallas (1925),Stella Dallas (1937), Madame X (1929), The Sin of Madelon Claudet (1931) and Blonde Venus (1932). Some similarities include the Goddess's fall from grace in society, although in contrast to many fallen women films this occurs before the start of the film, and her devotion to her child, willing to make great personal sacrifices to ensure a better life for him. However, while Goddess owes a narrative debt to these earlier Hollywood films, its quality has been enough to immortalize it as a worthy contemporary of them, particularly based on the strength of Ruan Lingyu's performance. In contemporary international film festivals, Ruan Lingyu has been featured alongside other prolific "fallen woman" actresses such as Marlene Dietrich and Barbara Stanwyck, and even nicknamed the "Garbo of the Orient", a reference to Greta Garbo.
Reception
Wu's directorial debut was received well back in 1934. Ruan Lingyu's popularity was cited as an influence, as well as the emotional appeal, with the Cultural Revolution affecting the acceptability of film content and styles. Interest in the "classic" film era for Chinese cinema returned internationally after Maggie Cheung's portrayal of Ruan Lingyu in the biopic Center Stage (1991), which recreates one of its scenes.
Cinematic techniques
Montage
A rapidly cut, rather kaleidoscope series of images that often condense but sometimes expand time and space.
Montage of iconic images of the streets: a passing tram car, people on a busy sidewalk in front of a window display of a mannequin in a swimsuit, and a fortune teller. (5:03 - 5:24) The montage here demonstrates that the Night Shanghai is a bustling, lively place where a variety of shops, peddlers are doing business. The fallen woman, Ruan's character, is also trying to make a living similar to the others.
Rapid montage of the police conducting a sweep on the streets for some unknown reasons. (8:51 - 9:15). This montage indicates the panic and fearfulness of the crowd and Ruan's character as they run, hide and escape in fast paces. It also shows that the residents do not have a positive impression on the police in 1930s China. Instead, they are scared of the police.
Dissolve
dissolve is a type of soft editing used to create a sense of dynamism within a single scene and between scenes. A series of dissolves at the climactic moment (between 1:10 and 1:11) shows the goddess's disorientation when she hits the thug over the head, which dissolves into the court sentencing her, and then her arrival in jail
Matte image
A type of special effect in which one area of the image is filmed, either by shooting a real background directly or painting one and shooting the painting while the remaining area is left blank by blocking a corresponding area of the lens, the blank area is then filled by filming with the opposite area being blocked, after which the two areas are combined in processing. In the perspective of the grinning thug, the Shanghai nightscape appears, and what makes him smile is a vision of the goddess, smiling and radiant over the city of night. (12:26) The matte image, made using the same double-exposure technique used in Laborer's love (1922), juxtaposes city and woman. Seen through the eyes of this lustful man, the city itself is personified as a sexually inviting woman who is out there and available. The matte image also demonstrates the prejudices that the vulnerable fallen women experience in Shanghai as powerful male oppression can perceive them as personal possessions arbitrarily.
Framing
The individual rectangular photographs on a strip of motion picture film, which when run through a projector, yield the impression of movement owing to slight variations in the position of the object being photographed.
The thug is often framed, from a low angle in medium close up, which emphasizes his larger than life presence. He literally takes up more of the screen space. When Ruan's character picks up the broken toy on the floor and looks up at the thug, the camera cuts to a shot of the mother crouching with her child framed between the man's legs. (24:46)
Ruan's character's crouching position between the man's legs demonstrates that she, as a victimized, weak woman is unable to escape from the terrifying and powerful man.
Ellipsis
When Ruan's character, now wearing a white dress, abruptly appears - her costume signaling a time jump between shots of her apartment and the night streets. (8:43)
The ellipsis makes the plot move forward and faster by excluding the unnecessary scenes and allowing the director to focus on the key plot directly.
Set Design:
Show the simplicity of the goddess's living quarters: a bed, a table, a few chairs, a hot water bottle, a couple of dresses and a few other possessions. (2:01 - 2:21) (2:56) When the fat, towering thug is in the room with her, the interior space becomes claustrophobic. (22:25). This indicates that the thug, as a significant figure, invades Ruan and her son, a suffering woman and a poor child's small, personal space as a male oppressor. Set design is stripped down to bare iconography - this is a space in which four nameless people - a woman, her child, a male oppressor and a male savior act out an elemental moral drama.
Editing
The process of splicing one shot to another; synonyms with cutting.
Brisk: A shot of only a few seconds. Overhead shot of the woman picking up a new client on the street, transition between scenes. (7:00 - 7:05) Shots of Shanghai's neon nightscape, inserted into a scene set in the woman's apartment, repeatedly contrast the vast, opaque city with the proximate and concrete image of one struggling individual. (8:24 -8:30) The alternation of interior and exterior scenes mimics the goddess's double life. The Shanghai neon nightscape represents her exterior status as a glamorous street walker while the small, sweet apartment represents her interior status as a caring domestic mother.
Normal: Editing of school talent show brings together the atomized narrative of the woman and her child and a broader narrative of social intolerance. Shots of the stage alternate with shots of the audience reaction, especially the woman's beaming face, conveying a sense of harmony and unity between performer and audience. (47:14) The shot of the goddess' beaming face and happy expression indicate that despite her profession, she is proud of her son as a caring and loving mother. This breaks down when her neighbor starts gossiping to the others about her profession; the cuts then seem to contrast the innocence of the children (46:38) with the depravity of the judgmental adults. (47:46)
Production release
December 7, 1934 Shanghai, China
April 22, 2014 China (4th Beijing International Film Festival) (restored version)
June 15, 2014 China (Shanghai International Film Festival) (restored version)
June 24, 2014 France (French Film archive) (restored version)
October 14, 2014 British (London Film Festival) (restored version)
Other release versions
In 2003, a DVD was released of the film, made from 35mm prints provided by The China Film Archive. This version came with a newly composed piano score by Kevin Purrone.
The University of Hong Kong Press repackaged the DVD film in 2005, combining it with a biography of Ruan Lingyu called Ruan Lingyu: The Goddess of Shanghai. While the original film only used Chinese intertitles for the silent film, both 2003 and 2005 versions of the DVD have English intertitles available.
Further reading
Henriot, Christian (2001). Prostitution and Sexuality in Shanghai: A Social History, 1849-1949. Cambridge University Press.
Hershatter, Gail (1999). Dangerous Pleasures: Prostitution and Modernity in Twentieth-Century Shanghai. University of California Press; First edition.
Harris, Kristine (2008). “The Goddess: Fallen Woman of Shanghai.” Chinese Films in Focus II, pp. 128–136.
Li, Guo (2012). Rethinking the Female Voice and the Ideology of Sound:On Stanley Kwan's film Center Stage (Ruan Lingyu, 1992). Film International vol. 10, no. 4, 2012, pp. 72-81.
References
External links
Goddess 神女 (1934) with English subtitles on YouTube
Chinese Film Classics online course, Module 3: Goddess (1934): full film with English subtitles and two video lectures, clips, links, at the scholarly website chinesefilmclassics.org
(English intertitles)
Translated intertitles for The Goddess
Essay on the film
More production information reference: Wood, Bret. "The Goddess (1934)." Turner Classic Movies. N.p., n.d. Web. May 2017.
1934 films
1934 drama films
Chinese silent films
Chinese drama films
1934 directorial debut films
Films about prostitution in China
Lianhua Film Company films
Films directed by Wu Yonggang
Chinese black-and-white films
Silent drama films
|
```c
/*********************************************************************/
/* All rights reserved. */
/* */
/* Redistribution and use in source and binary forms, with or */
/* without modification, are permitted provided that the following */
/* conditions are met: */
/* */
/* 1. Redistributions of source code must retain the above */
/* copyright notice, this list of conditions and the following */
/* disclaimer. */
/* */
/* 2. Redistributions in binary form must reproduce the above */
/* copyright notice, this list of conditions and the following */
/* disclaimer in the documentation and/or other materials */
/* provided with the distribution. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY OF TEXAS AT */
/* AUSTIN ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, */
/* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */
/* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */
/* DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OF TEXAS AT */
/* AUSTIN OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, */
/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES */
/* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE */
/* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR */
/* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF */
/* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */
/* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT */
/* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
/* POSSIBILITY OF SUCH DAMAGE. */
/* */
/* The views and conclusions contained in the software and */
/* documentation are those of the authors and should not be */
/* interpreted as representing official policies, either expressed */
/* or implied, of The University of Texas at Austin. */
/*********************************************************************/
#include <stdio.h>
#include "common.h"
#ifndef USE_ALPHA
#define REAL_PART(a, b) (a)
#define IMAGE_PART(a, b) (b)
#else
#define REAL_PART(a, b) (alpha_r * (a) - alpha_i * (b))
#define IMAGE_PART(a, b) (alpha_i * (a) + alpha_r * (b))
#endif
#if defined(REAL_ONLY)
#define CMULT(a, b) (REAL_PART(a, b))
#elif defined(IMAGE_ONLY)
#define CMULT(a, b) (IMAGE_PART(a, b))
#else
#define CMULT(a, b) (REAL_PART(a, b) + IMAGE_PART(a, b))
#endif
int CNAME(BLASLONG m, BLASLONG n, FLOAT *a, BLASLONG lda, BLASLONG posX, BLASLONG posY,
#ifdef USE_ALPHA
FLOAT alpha_r, FLOAT alpha_i,
#endif
FLOAT *b){
BLASLONG i, js, offset;
FLOAT data01;
FLOAT *ao1;
lda *= 2;
js = n;
while (js > 0){
offset = posX - posY;
if (offset > 0) ao1 = a + posY * 2 + (posX + 0) * lda; else ao1 = a + (posX + 0) * 2 + posY * lda;
i = m;
while (i > 0) {
data01 = CMULT(*(ao1 + 0), *(ao1 + 1));
if (offset > 0) ao1 += 2; else ao1 += lda;
b[ 0] = data01;
b ++;
offset --;
i --;
}
posX ++;
js --;
}
return 0;
}
```
|
```javascript
'use strict';
const common = require('../common');
const net = require('net');
const assert = require('assert');
const c = net.createConnection(common.PORT);
c.on('connect', common.mustNotCall());
c.on('error', common.mustCall(function(e) {
assert.strictEqual(e.code, 'ECONNREFUSED');
assert.strictEqual(e.port, common.PORT);
assert.strictEqual(e.address, '127.0.0.1');
}));
```
|
Terenin is a village in the administrative district of Gmina Pabianice, within Pabianice County, Łódź Voivodeship, in central Poland. It lies approximately south-west of Pabianice and south-west of the regional capital Łódź.
References
Villages in Pabianice County
|
San Giovanni de Butris is a Romanesque-style, Roman Catholic stone church located outside of the town of Acquasparta, on the former via Flaminia, in the Province of Terni, region of Umbria, Italy.
The stone church was initially built over the structure of an Ancient Roman bridge, which forms the visible base of the structure. It was initially dedicated to San Giovanni Battista, and once belonged to the Knights of Malta.
References
Churches in the province of Terni
Romanesque architecture in Umbria
|
```javascript
// Generated by ReScript, PLEASE EDIT WITH CARE
'use strict';
function test3(_n) {
while (true) {
let n = _n;
if (n === 0) {
return (n + 5 | 0) + 4 | 0;
}
_n = n - 1 | 0;
continue;
};
}
function test2(_n) {
while (true) {
let n = _n;
if (n === 0) {
return test3(n) + 3 | 0;
}
_n = n - 1 | 0;
continue;
};
}
function test0(_n) {
while (true) {
let n = _n;
if (n === 0) {
let _n$1 = n;
while (true) {
let n$1 = _n$1;
if (n$1 === 0) {
return test2(n$1) + 2 | 0;
}
_n$1 = n$1 - 1 | 0;
continue;
};
}
_n = n - 1 | 0;
continue;
};
}
let v = test0(10);
test0(10) + 2 | 0;
exports.v = v;
/* v Not a pure module */
```
|
```go
package humanize
import (
"fmt"
"math"
"strconv"
"strings"
"golang.org/x/exp/constraints"
)
// IEC Sizes.
// kibis of bits
const (
Byte = 1 << (iota * 10)
KiByte
MiByte
GiByte
TiByte
PiByte
EiByte
)
// SI Sizes.
const (
IByte = 1
KByte = IByte * 1000
MByte = KByte * 1000
GByte = MByte * 1000
TByte = GByte * 1000
PByte = TByte * 1000
EByte = PByte * 1000
)
func logn(n, b float64) float64 {
return math.Log(n) / math.Log(b)
}
func humanize_bytes(s uint64, base float64, sizes []string, sep string) string {
if s < 10 {
return fmt.Sprintf("%d%sB", s, sep)
}
e := math.Floor(logn(float64(s), base))
suffix := sizes[int(e)]
val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10
f := "%.0f%s%s"
if val < 10 {
f = "%.1f%s%s"
}
return fmt.Sprintf(f, val, sep, suffix)
}
// Bytes produces a human readable representation of an SI size.
// Bytes(82854982) -> 83 MB
func Bytes(s uint64) string {
return Size(s, SizeOptions{})
}
// IBytes produces a human readable representation of an IEC size.
// IBytes(82854982) -> 79 MiB
func IBytes(s uint64) string {
return Size(s, SizeOptions{Base: 1024})
}
type SizeOptions struct {
Separator string
Base int
}
func Size[T constraints.Integer | constraints.Float](s T, opts ...SizeOptions) string {
var o SizeOptions
prefix := ""
if len(opts) == 0 {
o = SizeOptions{}
} else {
o = opts[0]
}
if s < 0 {
prefix = "-"
}
if o.Separator == "" {
o.Separator = " "
}
if o.Base == 0 {
o.Base = 1000
}
var sizes []string
switch o.Base {
default:
sizes = []string{"B", "kB", "MB", "GB", "TB", "PB", "EB"}
case 1024:
sizes = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"}
}
return prefix + humanize_bytes(uint64(s), float64(o.Base), sizes, o.Separator)
}
func FormatNumber[T constraints.Float](n T, max_num_of_decimals ...int) string {
prec := 2
if len(max_num_of_decimals) > 0 {
prec = max_num_of_decimals[0]
}
ans := strconv.FormatFloat(float64(n), 'f', prec, 64)
return strings.TrimRight(strings.TrimRight(ans, "0"), ".")
}
```
|
Centre for Research of Orthodox Monarchism is a Serbian monarchist association from Belgrade, founded in 2001 and registered with the Ministry of Justice of Federal Republic of Yugoslavia in May 2002.
Its founder and first director was Nebojsha M. Krstich, also known as the founder of the Fatherland movement Obraz. Nebojsha died in an alleged car accident, on 4 December 2001. He was succeeded as the director of the Centre by Rev. Deacon Nenad M. Jovanovich, of the Serbian Orthodox Church. From 2008 until 2012 the director was Rev. Presbyter Boshko R. Marinkov, and since 2012 the director is Very Rev. Presbyter Nemanja S. Mrdjenovich.
Centre has five study committees and two volunteer sections. The five study committees are the Board for heraldry and genealogical studies, The Board for Cultural studies, the Board for Historiography, the Board for State and Legal studies, and the Board for Theological studies. Two volunteer sections are The Serbian Orthodox Action 'Sabor' and 'Society for fighting addiction diseases 'Svitanje' (Eng. 'dawn').
The Centre operates under the High Patronage of Prince Alexander (Paul's) Karageorgevich and Spiritual Patronage of Irinej (Dobrijevich) Bishop of the Metropolitanate of Australia and New Zealand of the Serbian Orthodox Church.
During their 'patron saint' celebration in June 2013, held at the Orthodox Theological Faculty of University of Belgrade, with the blessings of Serbian Patriarch Irinej, they received support from highest ranking representatives of the Serbian Orthodox Church, Serbian Army, and Crown Prince Alexander II Karageorgevich. In June 2014 the Centre received a St. Emperor Constantine medal, awarded by the Holy Synod of the Serbian Orthodox Church.
Centre is considered to be one of the highest authorities in Balkan heraldry. They have published books, including poetry and translations of monarchist books into Serbian. Their representatives participated in a number of international academic conferences. The official web site of CROM contains the largest collection of works on Orthodox monarchism in Serbian language.
2001 establishments in Serbia
Organizations based in Belgrade
Monarchism in Serbia
Monarchist organizations
Eastern Orthodoxy and politics
|
```php
<?php
/**
*/
namespace OCP\Files\Config;
use OCP\Files\Storage\IStorageFactory;
use OCP\IUser;
/**
* Provides
*
* @since 9.1.0
*/
interface IHomeMountProvider {
/**
* Get all mountpoints applicable for the user
*
* @param \OCP\IUser $user
* @param \OCP\Files\Storage\IStorageFactory $loader
* @return \OCP\Files\Mount\IMountPoint|null
* @since 9.1.0
*/
public function getHomeMountForUser(IUser $user, IStorageFactory $loader);
}
```
|
```java
package com.fishercoder.secondthousand;
import com.fishercoder.solutions.secondthousand._1464;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class _1464Test {
private _1464.Solution1 solution1;
private static int[] nums;
@BeforeEach
public void setup() {
solution1 = new _1464.Solution1();
}
@Test
public void test1() {
nums = new int[]{3, 4, 5, 2};
assertEquals(12, solution1.maxProduct(nums));
}
}
```
|
Nathaniel Monroe Kellogg (September 28, 1858July 19, 1923) was a Major League Baseball shortstop. He played in five games for the 1885 Detroit Wolverines. He continued to play in the minor leagues through 1891, primarily in the New England League and Northwestern League.
Sources
Major League Baseball shortstops
Detroit Wolverines players
Baseball players from Iowa
1858 births
1923 deaths
Nashville Americans players
Hamilton Clippers players
Duluth Freezers players
St. Paul Saints (Northwestern League) players
Buffalo Bisons (minor league) players
Manchester Maroons players
19th-century baseball players
|
The Mystery of Picasso () is a 1956 French documentary film directed by Henri-Georges Clouzot. In it, the painter Pablo Picasso produces 20 drawings and paintings, at first using inks that bleed through the paper on which he is drawing, with the act of creation filmed in real-time from the backside of the easel, and later using oil paints, with Clouzot employing a stop-motion-like effect to depict the development and modification of the works. The film begins with Picasso creating simple marker drawings in black and white, and he gradually progresses to full-scale collages and oil paintings.
The pieces created before the camera were supposedly subsequently destroyed so they would only exist on film, but there are reports that some survived.
Release
The Mystery of Picasso was released in France on 18 May 1956. It won the Special Jury Prize at the 1956 Cannes Film Festival and was shown out of competition at the 1982 Festival.
See also
Visit to Picasso – A short Belgian documentary from 1949 that employed a similar method to film Picasso at work. In both films, the artist was filmed from the backside of his work surface, but, in the earlier film, he painted on glass.
References
External links
French black-and-white films
French documentary films
1956 films
CinemaScope films
Films directed by Henri-Georges Clouzot
Pablo Picasso
Documentary films about painters
1956 documentary films
1950s French-language films
Films with screenplays by Henri-Georges Clouzot
1950s French films
|
Klaus Enders (2 May 1937 in Wetzlar, Germany – 20 January 2019) was a German Sidecar racer. He was a six-time FIM Sidecar World Champion and a four-time winner of the sidecar class at the Isle of Man TT. Enders decided to retire at the end of the 1970 season and try car racing, only to return to sidecars a year later, winning three more world titles before retiring for good at the end of 1974. His co-drivers were Wolfgang Kalauch and Ralf Engelhardt.
Enders died on 20 January 2019 at the age of 81 following a long illness.
References
1937 births
2019 deaths
Isle of Man TT riders
German motorcycle racers
People from Wetzlar
Sportspeople from Giessen (region)
Sidecar racers
Sportspeople from the Rhine Province
|
```javascript
import deepFreeze from 'deep-freeze';
import { getAuth } from '../accountsSelectors';
describe('getAuth', () => {
test('throws when no accounts', () => {
const state = deepFreeze({
accounts: [],
});
expect(() => {
getAuth(state);
}).toThrow();
});
test('throws when no API key', () => {
const state = deepFreeze({
accounts: [
{ apiKey: '', realm: 'path_to_url },
{ apiKey: 'asdf', realm: 'path_to_url },
],
});
expect(() => {
getAuth(state);
}).toThrow();
});
test('returns the auth information from the first account, if valid', () => {
const state = deepFreeze({
accounts: [
{ apiKey: 'asdf', realm: 'path_to_url },
{ apiKey: 'aoeu', realm: 'path_to_url },
],
});
expect(getAuth(state)).toEqual({
realm: 'path_to_url
apiKey: 'asdf',
});
});
});
```
|
```ocaml
open Import
module Main = Import.Main
let doc = "Build and view the documentation of an OCaml project"
let man =
[ `S "DESCRIPTION"
; `P
{|$(b,dune ocaml doc) builds and then opens the documentation of an OCaml project in the users default browser.|}
; `Blocks Common.help_secs
]
;;
let info = Cmd.info "doc" ~doc ~man
let term =
let+ builder = Common.Builder.term in
let common, config = Common.init builder in
let request (setup : Main.build_system) =
let dir = Path.(relative root) (Common.prefix_target common ".") in
let open Action_builder.O in
let+ () =
Alias.in_dir ~name:Dune_rules.Alias.doc ~recursive:true ~contexts:setup.contexts dir
|> Alias.request
in
let absolute_toplevel_index_path =
let toplevel_index_path =
let is_default ctx = ctx |> Context.name |> Dune_engine.Context_name.is_default in
let doc_ctx = List.find_exn setup.contexts ~f:is_default in
Dune_rules.Odoc.Paths.toplevel_index doc_ctx
in
Path.(toplevel_index_path |> build |> to_string_maybe_quoted)
in
Console.print
[ Pp.textf "Docs built. Index can be found here: %s" absolute_toplevel_index_path ];
match
let open Option.O in
let* cmd_name, args =
match Platform.OS.value with
| Darwin -> Some ("open", [ "-u" ])
| Other | FreeBSD | NetBSD | OpenBSD | Haiku | Linux -> Some ("xdg-open", [])
| Windows -> None
in
let+ open_command =
let path = Env_path.path Env.initial in
Bin.which ~path cmd_name
in
( open_command
, (* First element of argv is the name of the command. *)
let url = "file://" ^ absolute_toplevel_index_path in
(cmd_name :: args) @ [ url ] )
with
| Some (cmd, args) ->
Proc.restore_cwd_and_execve (Path.to_absolute_filename cmd) args ~env:Env.initial
| None ->
User_warning.emit
[ Pp.text
"No browser could be found, you will have to open the documentation yourself."
]
in
Build_cmd.run_build_command ~common ~config ~request
;;
let cmd = Cmd.v info term
```
|
Larry Darnell Flowers (born April 19, 1958) is a former professional American football player who played safety for five seasons for the New York Giants and the New York Jets.
1958 births
Living people
Players of American football from Temple, Texas
American football safeties
Texas Tech Red Raiders football players
New York Giants players
New York Jets players
|
```objective-c
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing,
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* specific language governing permissions and limitations
*/
/*!
* \file pipe.h
* \brief Platform independent pipe, used for IPC.
*/
#ifndef TVM_SUPPORT_PROCESS_ID_H_
#define TVM_SUPPORT_PROCESS_ID_H_
#include <iomanip>
#include <ios>
#include <sstream>
#include <string>
#include <thread>
#ifdef _WIN32
#include <windows.h>
#else
#include <sys/types.h>
#include <unistd.h>
#endif
namespace tvm {
namespace support {
/*! \brief Returns the PID of the current process as an 64-bit signed integer. */
inline int64_t GetProcessId() {
int64_t result;
#ifdef _WIN32
DWORD pid = GetCurrentProcessId();
result = static_cast<int64_t>(pid);
#else
pid_t pid = getpid();
result = static_cast<int64_t>(pid);
#endif
return result;
}
/*! \brief Returns the PID and TIR of the current process/thread as a formatted string */
inline std::string GetProcessIdAndThreadIdHeader() {
std::ostringstream os;
os << "[PID " << GetProcessId() << " TID 0x" << std::setw(16) << std::setfill('0') << std::hex
<< std::this_thread::get_id() << "]";
return os.str();
}
} // namespace support
} // namespace tvm
#endif // TVM_SUPPORT_PROCESS_ID_H_
```
|
```objective-c
//
// wchar.h
//
//
// All of the types, macros, and function declarations for all wide-character
// related functionality. Most of the functionality is in the #included
// <corecrt_wxxxx.h> headers, which are also #included by other public headers.
//
#pragma once
#define _INC_WCHAR
#include <corecrt.h>
#include <corecrt_memcpy_s.h>
#include <corecrt_wconio.h>
#include <corecrt_wctype.h>
#include <corecrt_wdirect.h>
#include <corecrt_wio.h>
#include <corecrt_wprocess.h>
#include <corecrt_wstdio.h>
#include <corecrt_wstdlib.h>
#include <corecrt_wstring.h>
#include <corecrt_wtime.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <vcruntime_string.h>
_CRT_BEGIN_C_HEADER
#define WCHAR_MIN 0x0000
#define WCHAR_MAX 0xffff
typedef wchar_t _Wint_t;
_Check_return_opt_
_ACRTIMP wchar_t* __cdecl _wsetlocale(
_In_ int _Category,
_In_opt_z_ wchar_t const* _Locale
);
_Check_return_opt_
_ACRTIMP _locale_t __cdecl _wcreate_locale(
_In_ int _Category,
_In_z_ wchar_t const* _Locale
);
_ACRTIMP wint_t __cdecl btowc(
_In_ int _Ch
);
_ACRTIMP size_t __cdecl mbrlen(
_In_reads_bytes_opt_(_SizeInBytes) _Pre_opt_z_ char const* _Ch,
_In_ size_t _SizeInBytes,
_Inout_ mbstate_t* _State
);
_ACRTIMP size_t __cdecl mbrtowc(
_Pre_maybenull_ _Post_z_ wchar_t* _DstCh,
_In_reads_bytes_opt_(_SizeInBytes) _Pre_opt_z_ char const* _SrcCh,
_In_ size_t _SizeInBytes,
_Inout_ mbstate_t* _State
);
_Success_(return == 0)
_ACRTIMP errno_t __cdecl mbsrtowcs_s(
_Out_opt_ size_t* _Retval,
_Out_writes_opt_z_(_Size) wchar_t* _Dst,
_In_ size_t _Size,
_Deref_pre_opt_z_ char const** _PSrc,
_In_ size_t _N,
_Inout_ mbstate_t* _State
);
__DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_3(
_Success_(return == 0)
errno_t, mbsrtowcs_s,
_Out_opt_ size_t*, _Retval,
_Post_z_ wchar_t, _Dest,
_Inout_ _Deref_prepost_opt_valid_ char const**, _PSource,
_In_ size_t, _Count,
_Inout_ mbstate_t*, _State
)
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE(
_Success_(return == 0) _ACRTIMP, mbsrtowcs,
_Out_writes_opt_z_(_Count), wchar_t, _Dest,
_Deref_pre_opt_z_ char const**, _PSrc,
_In_ size_t, _Count,
_Inout_ mbstate_t*, _State
)
_Success_(return == 0)
_ACRTIMP errno_t __cdecl wcrtomb_s(
_Out_opt_ size_t* _Retval,
_Out_writes_opt_z_(_SizeInBytes) char* _Dst,
_In_ size_t _SizeInBytes,
_In_ wchar_t _Ch,
_Inout_opt_ mbstate_t* _State
);
__DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_2(
_Success_(return == 0)
errno_t, wcrtomb_s,
_Out_opt_ size_t*, _Retval,
_Out_writes_opt_z_(_Size) char, _Dest,
_In_ wchar_t, _Source,
_Inout_opt_ mbstate_t*, _State
)
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE(
_ACRTIMP, wcrtomb,
_Pre_maybenull_ _Post_z_, char, _Dest,
_In_ wchar_t, _Source,
_Inout_opt_ mbstate_t*, _State
)
_Success_(return == 0)
_ACRTIMP errno_t __cdecl wcsrtombs_s(
_Out_opt_ size_t* _Retval,
_Out_writes_bytes_to_opt_(_SizeInBytes, *_Retval) char* _Dst,
_In_ size_t _SizeInBytes,
_Inout_ _Deref_prepost_z_ wchar_t const** _Src,
_In_ size_t _Size,
_Inout_opt_ mbstate_t* _State
);
__DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_3(
_Success_(return == 0)
errno_t, wcsrtombs_s,
_Out_opt_ size_t*, _Retval,
_Out_writes_opt_z_(_Size) char, _Dest,
_Inout_ _Deref_prepost_z_ wchar_t const**, _PSrc,
_In_ size_t, _Count,
_Inout_opt_ mbstate_t*, _State
)
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE(
_ACRTIMP, wcsrtombs,
_Pre_maybenull_ _Post_z_, char, _Dest,
_Inout_ _Deref_prepost_z_ wchar_t const**, _PSource,
_In_ size_t, _Count,
_Inout_opt_ mbstate_t*, _State
)
_ACRTIMP int __cdecl wctob(
_In_ wint_t _WCh
);
#ifndef __midl
#if __STDC_WANT_SECURE_LIB__
_Success_(return == 0)
errno_t __CRTDECL wmemcpy_s(
_Out_writes_to_opt_(_N1, _N) wchar_t* _S1,
_In_ rsize_t _N1,
_In_reads_opt_(_N) wchar_t const* _S2,
_In_ rsize_t _N
);
_Success_(return == 0)
errno_t __CRTDECL wmemmove_s(
_Out_writes_to_opt_(_N1, _N) wchar_t* _S1,
_In_ rsize_t _N1,
_In_reads_opt_(_N) wchar_t const* _S2,
_In_ rsize_t _N
);
#endif // __STDC_WANT_SECURE_LIB__
__inline int __CRTDECL fwide(
_In_opt_ FILE* _F,
_In_ int _M
)
{
_CRT_UNUSED(_F);
return (_M);
}
__inline int __CRTDECL mbsinit(
_In_opt_ mbstate_t const* _P
)
{
return _P == NULL || _P->_Wchar == 0;
}
__inline wchar_t _CONST_RETURN* __CRTDECL wmemchr(
_In_reads_(_N) wchar_t const* _S,
_In_ wchar_t _C,
_In_ size_t _N
)
{
for (; 0 < _N; ++_S, --_N)
if (*_S == _C)
return (wchar_t _CONST_RETURN*)_S;
return 0;
}
__inline int __CRTDECL wmemcmp(
_In_reads_(_N) wchar_t const* _S1,
_In_reads_(_N) wchar_t const* _S2,
_In_ size_t _N
)
{
for (; 0 < _N; ++_S1, ++_S2, --_N)
if (*_S1 != *_S2)
return *_S1 < *_S2 ? -1 : 1;
return 0;
}
_Post_equal_to_(_S1)
_At_buffer_(_S1, _Iter_, _N, _Post_satisfies_(_S1[_Iter_] == _S2[_Iter_]))
__inline _CRT_INSECURE_DEPRECATE_MEMORY(wmemcpy_s)
wchar_t* __CRTDECL wmemcpy(
_Out_writes_all_(_N) wchar_t* _S1,
_In_reads_(_N) wchar_t const* _S2,
_In_ size_t _N
)
{
#pragma warning(push)
#pragma warning(disable : 4995 4996 6386)
return (wchar_t*)memcpy(_S1, _S2, _N*sizeof(wchar_t));
#pragma warning(pop)
}
__inline _CRT_INSECURE_DEPRECATE_MEMORY(wmemmove_s)
wchar_t* __CRTDECL wmemmove(
_Out_writes_all_opt_(_N) wchar_t* _S1,
_In_reads_opt_(_N) wchar_t const* _S2,
_In_ size_t _N
)
{
#pragma warning(push)
#pragma warning(disable : 4996 6386)
return (wchar_t*)memmove(_S1, _S2, _N*sizeof(wchar_t));
#pragma warning(pop)
}
_Post_equal_to_(_S)
_At_buffer_(_S, _Iter_, _N, _Post_satisfies_(_S[_Iter_] == _C))
__inline wchar_t* __CRTDECL wmemset(
_Out_writes_all_(_N) wchar_t* _S,
_In_ wchar_t _C,
_In_ size_t _N
)
{
wchar_t *_Su = _S;
for (; 0 < _N; ++_Su, --_N)
{
*_Su = _C;
}
return _S;
}
#ifdef __cplusplus
extern "C++" inline wchar_t* __CRTDECL wmemchr(
_In_reads_(_N) wchar_t* _S,
_In_ wchar_t _C,
_In_ size_t _N
)
{
wchar_t const* const _SC = _S;
return const_cast<wchar_t*>(wmemchr(_SC, _C, _N));
}
#endif // __cplusplus
#endif // !__midl
_CRT_END_C_HEADER
```
|
The Old Library (sometimes Old Carnegie Library) is a building on Queens Square in Wrexham city centre, Wales. Built as a carnegie library in 1907, the building served as Wrexham's public library until 1973, when it later became council offices. The building is Grade II listed and council-owned, although Wrexham Council announced it plans to sell the building from 2020, and has yet to find a new occupant.
History
The building was constructed as a library and lecture hall in 1907. It was designed by Vernon Hodge. Over 100 architects had submitted designs for the new library. The building is a Grade II listed building, and located in Wrexham city centre's Queens Square.
The construction received funding from Scottish-American philanthropist Andrew Carnegie following an appeal over the lack of space for books in the town's existing library located in the Guildhall. A grant of £4,000 to build and £300 to furnish the library was provided from Carnegie for the building's construction.
Mayoress of Wrexham, Mrs Birkett Evans laid the building's foundation stone on 1 January 1906. The building was opened on 15 February 1907 by Foster Cunliffe of Acton Hall.
During World War II, the building housed 500 juvenile and 700 adult books from Liverpool Library following the evacuation of 9,600 children from Merseyside. The blackout during the war led to an increase in reading, with the number of library borrowers "dramatically" increasing during the war. The Food Office and an Information Bureau, were set up in part of the library during the war.
The building was enlarged in 1951, at the cost of £6,641, modernising facilities and the addition of a "Wrexham Room" for books, illustrations, manuscripts, records of local interest, and an "Exhibition Room" to display art, craft and lectures.
The building was vacated of its library function in 1973, with the library being superseded by the current library located on Llwyn Isaf, with the current library opening in 1974. Since 1973, the Old Library building has been used as council offices. The building is owned by Wrexham County Borough Council, and as of 2023, it is used to house the council's IT department.
Sale
In December 2020, Wrexham council announced it was planning to sell the building. This follows previous revelations that the council were vacating the building by moving their IT systems from the building into the renovated Crown Buildings. In January 2023, the council asked for any expressions of interest from any potential new occupiers, and described the building as "under used".
In February 2023, a councillor called for the building to be made available for public use. The council refused to comment.
Structure
The building is two storeys, with a graded slate roof, an ashlar lower storey and dressings, and is covered in Flemish-bond brickwork on the upper floor's exterior. The building used Cefn stone and Ruabon terracotta during its construction, while the front roof was made of Westmorland slate, and the back roof with Bangor slate. The main part of the building has a symmetrical five-window range in the baroque style. The central bay is stressed with pilasters to a segmental open pediment, with a coat of arms. The building's central entrance is recessed as a segmental archway, with heavy keystones beneath a steep pediment which is carried by heavy brackets. The porch is enclosed with iron gates. The lower storey is arched with segmentally-arched tripartite small-paned windows with keystones to continuous hood moulds.
While used as a library, the ground floor of the building contained a Ladies Room, seating 20 readers, a reference room of a similar size, a general reading room seating 50 readers and a librarian's office. The lending library had the capacity to hold 20,000 volumes. The first floor of the building contained a large lecture hall, seating 200 people. This lecture hall later became a local museum, then a reference room, meeting room, book-club room and a book store.
References
Buildings and structures in Wrexham
Grade II listed buildings in Wrexham County Borough
Carnegie libraries in Wales
Grade II listed library buildings
Libraries in Wales
Former library buildings in Wales
Library buildings completed in 1907
1907 establishments in Wales
|
John Lynch was the president and CEO of the Broadcast Company of the Americas.
Early life
John Lynch grew up in suburban Chicago in an Irish-Catholic family. His grandparents were Irish immigrants. His grandparents named their son (Lynch's father) John Pershing Lynch, after the World War I general of the same name. Lynch graduated from Benet Academy in 1965, and went on to major in broadcasting at Drake University, where he also played football as linebacker and tight end. He was drafted right out of college to play linebacker for the Pittsburgh Steelers in 1969. A knee injury in the first few weeks of the season immediately ended his football career after one season, however.
Broadcasting career
Following the end of his football career with the Pittsburgh Steelers, Lynch sold advertising for the Chicago Tribune and later WIND (AM), then owned by Westinghouse Radio. In 1972, he convinced his boss at Westinghouse to relocate him to San Diego and make him sales manager at KFMB AM/FM, owned by Midwest Radio and Television. He moved with his wife Cathy, whom he met in high school, and their two toddlers. The KFMB stations were struggling when Lynch began his work there, but within five years they achieved the highest ratings in the market.
In 1978, Ed Noble offered Lynch a five-percent ownership of the Noble Broadcast Group, based in San Diego. The company bought XTRA AM/FM, and the AM station became the first all-sports talk show in the US. The FM station did not do too well with its album-oriented rock programming, so Lynch switched to alternative rock instead and created 91X. Upon Noble's death in 1985, Lynch took over the company and over the following decade expanded into 20 stations throughout the nation. In 1996 he sold the company to Jacor Communications for $152 million, which was bought by Clear Channel Communications soon after. Over the next five years, a noncompete agreement barred Lynch from the radio industry, so during that time he presided over the San Diego International Sports Council and helped bring the 2008 U.S. Open Golf Championship to San Diego.
In 2003, Lynch learned from his daughter Kara Guthrie, who headed sports sales for Clear Channel, that her company decided to move XTRA Sports to Los Angeles. As XTRA Sports was the only local sports talk show in San Diego, the void and laid-off staff essentially gave Lynch a "ready-made radio station" to pick up. He and a partner from Noble established the Broadcast Company of the Americas and started Mighty 1090.
Personal life
Lynch's son is the NFL's John Lynch Jr.
References
Radio personalities from Chicago
Living people
Radio personalities from San Diego
Year of birth missing (living people)
|
Dogtooth (; Kynodontas) is a 2009 Greek absurdist psychological drama film directed by Yorgos Lanthimos. Written by Lanthimos and Efthymis Filippou, the film is about a husband and wife (Christos Stergioglou and Michelle Valley) who keep their children (Angeliki Papoulia, Christos Passalis, and Mary Tsoni) ignorant of the world outside their property well into adulthood.
Dogtooth is Lanthimos's third feature film. It won the Prix Un Certain Regard at the 2009 Cannes Film Festival and was nominated for Best Foreign Language Film at the 83rd Academy Awards.
Plot
A couple live in a fenced-in compound with their adult son and two adult daughters. The children have no knowledge of the outside world; their parents say they will be ready to leave once they lose a dogtooth, and that one can only leave safely by car. The children entertain themselves with endurance games, such as keeping a finger in hot water. They believe they have a brother on the other side of the fence to whom they throw supplies or stones. The parents reward good behavior with stickers and punish bad behavior with violence.
The father pays a security guard at his factory, Christina, to come to the house and have sex with his son. Frustrated by the boy's refusal to give her cunnilingus, Christina trades her headband with the elder daughter in exchange for oral sex from her. The elder daughter persuades the younger daughter to lick her shoulder by bartering the headband. Later, the younger daughter volunteers to lick the elder again. The elder has nothing to offer in exchange, but the younger does not mind and experiments by licking other body parts.
The father visits a dog-training facility and demands to have his dog returned. The trainer refuses because the dog has not finished its training, and asks: "Do we want an animal or a friend?"
When the children are terrified by a stray cat in the garden, the son kills it with a pair of pruning shears. Deciding to take advantage of the incident, the father shreds his clothes, covers himself in fake blood, and tells his children that their unseen brother was killed by a cat, the most dangerous creature. After he teaches them to bark on all fours to fend off cats, the family holds a memorial service for the brother.
Christina again barters for oral sex from the elder daughter. The daughter rejects her offer of hair gel and demands the Hollywood videotapes in her bag. She watches the films in secret and afterward recreates scenes and quotes their dialogue. When the father discovers the tapes, he beats her with one of them, then goes to Christina's flat and hits her with her VCR, cursing her future children to be corrupted by "bad influences".
The parents decide that, with Christina no longer available, they will have their son choose one of his sisters as a new sexual partner. After fondling both sisters with his eyes closed, he chooses the elder. She is uncomfortable during their sex and afterward recites threatening dialogue from a Hollywood film to her brother.
During a dance performance for the parents' wedding anniversary, the younger daughter stops to rest, but the elder continues, performing the choreography from the film Flashdance (1983), disturbing her parents. That night, she knocks out one of her dogteeth with a dumbbell and hides in the boot of her father's car. The father discovers her tooth fragments and searches for her fruitlessly. He drives to work the next day; the car sits outside the factory, unattended.
Cast
Production
Dogtooth was the feature film début for Boo Productions, an Athens-based advertising company. The Greek Film Center supported the project with about €200,000 and much of the production was done with help from volunteers. Another €50,000 was offered by the production studio, bringing the overall budget to €250,000. Anna Kalaitzidou and Christos Passalis were stage actors who were cast after having worked with Lanthimos earlier. Mary Tsoni was not a professional actress, but a singer in a punk band. Lanthimos had an open approach to both acting and visual style and felt it would look fake if he involved himself too much in the details. Only when rehearsals started did he begin to develop an idea of the style in which the film should be shot: one where he tried to combine a realistic environment with "really strict framing and a cool, surreal look to go with the narrative".
Release
The film premiered on 18 May 2009 at the Cannes Film Festival, and went on to screen at festivals such as Toronto and Maryland. It was released in Greece on 11 November 2009 through Feelgood Entertainment. Verve Pictures picked up the British distribution rights and launched it on 23 April 2010. The American premiere was on 25 June 2010, managed by Kino International.
Reception
Greek critic Dimitris Danikas gave Dogtooth a rating of eight out of ten ("with enthusiasm"), calling it "black, surreal, nightmarish" and writing that Dogtooth is as important for Greek cinema as Theodoros Angelopoulos's 1970 film Reconstitution. Danikas added, "Lanthimos composes and goes from one level to another like a wildcat-creator, constantly and continuously maintaining the same rigorous style. Hence the aphasia; hence the uniformity; hence the submission and the scheduled mass culture; hence also the serial killer; hence, however, the disobedience, the anarchy. As I said at the beginning: Dogtooth has the surrealism of Buñuel, the scalpel of Haneke, the underground horror of a thriller without the splatter. Perfect." Danikas characterized Dogtooth's Academy Award nomination as "the greatest Greek triumph of recent years." Columnist Dimitris Bouras, writing for Kathimerini, mentioned "the beneficial effects that the prestigious award could have" and wrote that the nomination reveals three interesting facts: "1) in Greece we need to be extroverts (and not only in cinema), 2) exportable product is whatever has an identity, 3) Dogtooths nomination is like an investment – manna from the heaven of Hollywood for the developing Greek cinema."
International
On review aggregator website Rotten Tomatoes, the film has a 93% approval rating based on review from 70 critics, with an average score of 7.70/10; the site's "critics consensus" reads: "It'll be too disturbing – and meandering – for some, but Dogtooth is as disturbing and startlingly original as modern filmmaking gets". On Metacritic, the film has a weighted average score of 73 out of 100 based on 17 critics, indicating "generally favorable reviews".
Alistair Harkness of The Scotsman hailed Lanthimos as "a bold new voice on the world cinema scene, someone who might soon be elevated to a similar position as those twin pillars of Euro provocation: Lars von Trier and Michael Haneke", but added that the film is "not... designed simply to shock in the way von Trier's work often does,... nor does it have that annoyingly prescriptive, punitive air of superiority favoured by Haneke's films."
Peter Bradshaw of The Guardian praised the filmmaking, finding Dogtooth "superbly shot, with some deadpan, elegant compositions, and intentionally skewiff framings". Roger Ebert of the Chicago Sun-Times gave the film three out of four stars, noting the director's "complete command of visuals and performances. His cinematography is like a series of family photographs of a family with something wrong with it. His dialogue sounds composed entirely of sentences memorized from tourist phrase books." Mark Olsen of the Los Angeles Times wrote that "All of the film's purposeful weirdness is conveyed with an unaffected simplicity that recalls the dead-aim haphazard compositions of photographer William Eggleston", concluding that, "as a film, it's pure and singular, but it's not quite fully formed enough to be what one could call truly visionary."
A. O. Scott of The New York Times wrote that the film "at times seems as much an exercise in perversity as an examination of it", and that "The static wide-screen compositions are beautiful and strange, with the heads and limbs of the characters frequently cropped. The light is gauzy and diffuse, helping to produce an atmosphere that is insistently and not always unpleasantly dreamlike. You might think of paintings by Balthus or maybe Alex Katz, though the implied stories in those pictures are more genuinely evocative and haunting than the actual narrative of Dogtooth."
Several reviewers, such as Harkness and Bradshaw, made comparisons to the 2008 Fritzl case, although they noted that the screenplay was written before the case emerged. Scott, like Ebert, made references to homeschooling. Resemblances have been noted to the 1972 Mexican film The Castle of Purity.
The film's larger meaning eluded easy expression. Scott called the film "a conversation piece. Though the conversation may... be more along the lines of: 'What was that?' 'I don't know. Weird.' 'Yeah.' [shudder]. 'Weird.'" Olsen saw Dogtooths substance as "part enigma, part allegory and even part sci-fi in its creation of a completely alternate reality." Ebert found a "message" in the film, which he put as: "God help children whose parents insanely demand unquestioning obedience to their deranged standards.... [S]ome have even described the film as a comedy. I wasn't laughing." For Bradshaw, the film investigates "the essential strangeness of something society insists is the benchmark of normality: the family, a walled city state with its own autocratic rule and untellable secrets." Harkness noted the "absolute mockery the situation makes of the perfect family ideal", where "Lanthimos isn't interested in making specific political or social points and he refuses to offer any clarifying backstory", and found Dogtooths oddness "as organic and playful as its impact is incisor sharp."
In a 2012 interview, filmmaker David Lynch called Dogtooth "a fantastic comedy".
Accolades
Greek Prime Minister George Papandreou ended the Cabinet meeting on 25 January 2011 by saying: "The news that the film Dogtooth by Yorgos Lanthimos is nominated for Best Foreign Language Film goes far beyond the world of cinema, arts and culture. It concerns the whole country, its people, the new generation of artists who follow the motto 'Yes, we can do it' during difficult times." He continued, "I won't say that the news shows that miracles happen, because the success of Yorgos Lanthimos is based on hard work, talent and his endless potential. Features that characterize the creative forces which lead Greece to a new era; forces which deserve our support and they will have it. Bravo Yorgos."
The Greek Film Committee unanimously chose Dogtooth to represent Greece at the Oscars.
Potential influences
In 1970, Mexican filmmaker Arturo Ripstein made a very similar film, The Castle of Purity, in which a man keeps his family isolated, the brother and sister have an unusually close connection, and the sister is the one to break the impasse with the outside world. According to Ripstein, his film was based on a story that appeared in newspapers in the 1950s about a man who isolated his family and did not allow them to leave, saying that "There was a lot of talk about the case when I was a little boy." The case inspired two works: La Carcajadas del Gato, a novel by Luis Spota, and Los Motivos del Lobos, a play by Sergio Galindo. Actress Dolores del Río was interested in the rights to the play, and contacted Luis Buñuel to direct. He declined, but recommended his protege, Ripstein, who said: "Dolores del Río called and said, 'I would like to make an adaptation of the play', and I said, 'I would prefer to go directly to the source and take the case from the newspapers'."
See also
List of Greek submissions for the Academy Award for Best Foreign Language Film
List of submissions to the 83rd Academy Awards for Best Foreign Language Film
References
External links
2009 films
2009 drama films
2009 independent films
2009 LGBT-related films
Greek drama films
Greek LGBT-related films
Films set in Greece
Films shot in Athens
2000s Greek-language films
Films directed by Yorgos Lanthimos
Films about dysfunctional families
Films shot in Greece
Films about child abuse
Incest in film
Lesbian-related films
2000s psychological drama films
2000s Greek films
|
The Funen Life Regiment () was an infantry regiment of the Royal Danish Army. On 1 November 1991 it was merged with the King's Jutlandic Regiment of Foot, into Slesvigske Fodregiment.
History
It was one of the oldest regiments in the Danish army and could trace its history back to 1614 when it was raised under the name Fynske Fenle Knægte af Jydske Regiment Landsfolk. The Regiment participated in all Danish wars since 1625, including Torstenson War (1643–1645) Northern Wars (1658–1660), Scanian War (1675–1679), Great Northern War (1700), Great Northern War (1709–1720), Slaget på Reden (1801), Gunboat War (1807–1814), First Schleswig War (1848–1850) and Second Schleswig War (1864). It was furthermore in foreign war service during 1689–1714. The regimental flag has the battle honours Lutter am Barenberg 1626, Wismar 1675, Christianstad 1677–78, Stralsund 1715, Dybbøl 1848, Isted 1850 and Dybbøl 1864.
Organisation
Disband units
1st battalion (I/FLR), Founded 1961, Disband 1990. Mechanized Infantry Battalion
Staff Company
1st Armored Infantry Company
2nd Armored Infantry Company
(blue) 3rd Tank Squadron (Along with from 1974 to 1981)
4th Motorised Infantry Company
2nd battalion (II/FLR), Founded 1961, Disband 1990. Infantry Battalion.
Staff Company
1st Motorised Infantry Company
2nd Motorised Infantry Company
3rd Motorised Infantry Company
3rd battalion (III/FLR), Founded 1961, Disband 1990. Infantry Battalion.
Staff Company
1st Infantry Company
2nd Infantry Company
3rd Infantry Company
4th battalion (IV/FLR), Founded 1961, Disband 1990. Motorised Infantry Battalion.
Staff Company
1st Motorised Infantry Company
2nd Motorised Infantry Company
3rd Motorised Infantry Company
4th Tank Destroyer Squadron
Names of the regiment
Standards
References
Lærebog for Hærens Menige, Hærkommandoen, marts 1960
Danish Army regiments
1614 establishments in Denmark
Military units and formations established in 1614
Military units and formations disestablished in 1991
|
Worthen is an unincorporated community in Galla Township, Pope County, Arkansas, United States. It is located on US Route 64 approximately 1.5 miles east of Pottsville.
References
Unincorporated communities in Pope County, Arkansas
Unincorporated communities in Arkansas
|
```smalltalk
using System;
using UnityEditor;
using UnityEngine;
public class WelcomeScreen : EditorWindow
{
private string version = "Version : 1.0.0";
private bool flag = true;
private Rect mContactDescriptionRect = new Rect(70f, 344f, 250f, 30f);
private Rect mContactHeaderRect = new Rect(70f, 324f, 250f, 20f);
private Texture mContactImage;
private Rect mContactImageRect = new Rect(15f, 322f, 50f, 50f);
private Rect mDocDescriptionRect = new Rect(70f, 143f, 260f, 30f);
private Rect mDocHeaderRect = new Rect(70f, 123f, 350f, 20f);
private Texture mDocImage;
private Rect mDocImageRect = new Rect(15f, 124f, 53f, 50f);
private Rect mForumDescriptionRect = new Rect(70f, 278f, 380f, 30f);
private Rect mForumHeaderRect = new Rect(70f, 258f, 250f, 20f);
private Texture mForumImage;
private Rect mForumImageRect = new Rect(15f, 256f, 50f, 50f);
private Rect mSamplesDescriptionRect = new Rect(70f, 77f, 250f, 30f);
private Rect mSamplesHeaderRect = new Rect(70f, 57f, 250f, 20f);
private Texture mSamplesImage;
private Rect mSamplesImageRect = new Rect(15f, 58f, 50f, 50f);
private Rect mToggleButtonRect = new Rect(280f, 385f, 125f, 20f);
private Rect mVersionRect = new Rect(5f, 385f, 125f, 20f);
private Rect mVideoDescriptionRect = new Rect(70f, 209f, 380f, 30f);
private Rect mVideoHeaderRect = new Rect(70f, 189f, 350f, 20f);
private Texture mVideoImage;
private Rect mVideoImageRect = new Rect(15f, 190f, 50f, 50f);
private Rect mWelcomeIntroRect = new Rect(10f, 12f, 400f, 40f);
private Texture mWelcomeScreenImage;
private Rect mWelcomeScreenImageRect = new Rect(0f, 0f, 340f, 44f);
public void OnEnable()
{
//this.mWelcomeScreenImage = EditorGUIUtility.Load("WelcomeScreenHeader.png") as Texture;
//BehaviorDesignerUtility.LoadTexture("WelcomeScreenHeader.png", false, this);
flag = PlayerPrefs.GetInt("ShowWelcomeScreen", 1) == 1;
this.mSamplesImage = LoadTexture("WelcomeScreenSamplesIcon.png");
this.mDocImage = LoadTexture("WelcomeScreenDocumentationIcon.png");
this.mVideoImage = LoadTexture("WelcomeScreenVideosIcon.png");
this.mForumImage = LoadTexture("WelcomeScreenForumIcon.png");
this.mContactImage = LoadTexture("WelcomeScreenContactIcon.png");
}
Texture LoadTexture(string name) {
string path = "Assets/LuaFramework/Examples/Editor Default Resources/";
return (Texture)AssetDatabase.LoadAssetAtPath(path + name, typeof(Texture));
}
public void OnGUI()
{
//GUI.DrawTexture(this.mWelcomeScreenImageRect, this.mWelcomeScreenImage);
GUI.Label(this.mWelcomeIntroRect, "LuaFrameworktolua#\nC#LuaAssetBundle");
GUI.DrawTexture(this.mSamplesImageRect, this.mSamplesImage);
GUI.Label(this.mSamplesHeaderRect, " - Wrap()" );
GUI.Label(this.mSamplesDescriptionRect, "LuaGenerate All.");
GUI.DrawTexture(this.mDocImageRect, this.mDocImage);
GUI.Label(this.mDocHeaderRect, " - AssetBundle()");
GUI.Label(this.mDocDescriptionRect, "GameBuild XXX Resources.");
GUI.DrawTexture(this.mVideoImageRect, this.mVideoImage);
GUI.Label(this.mVideoHeaderRect, " - LuaC#");
GUI.Label(this.mVideoDescriptionRect, "LuaClear Wrap Files.");
GUI.DrawTexture(this.mForumImageRect, this.mForumImage);
GUI.Label(this.mForumHeaderRect, " - LuaUTF-8");
GUI.Label(this.mForumDescriptionRect, "LuaEncode LuaFile with UTF-8.");
GUI.DrawTexture(this.mContactImageRect, this.mContactImage);
GUI.Label(this.mContactHeaderRect, " ");
GUI.Label(this.mContactDescriptionRect, "QQ:469941220 QQ:62978170");
GUI.Label(this.mVersionRect, version );
flag = GUI.Toggle(this.mToggleButtonRect, flag, "");
if (flag) {
PlayerPrefs.SetInt("ShowWelcomeScreen", 1);
} else {
PlayerPrefs.SetInt("ShowWelcomeScreen", 0);
}
EditorGUIUtility.AddCursorRect(this.mSamplesImageRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mSamplesHeaderRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mSamplesDescriptionRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mDocImageRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mDocHeaderRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mDocDescriptionRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mVideoImageRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mVideoHeaderRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mVideoDescriptionRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mForumImageRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mForumHeaderRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mForumDescriptionRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mContactImageRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mContactHeaderRect, MouseCursor.Link);
EditorGUIUtility.AddCursorRect(this.mContactDescriptionRect, MouseCursor.Link);
if (Event.current.type == EventType.MouseUp)
{
Vector2 mousePosition = Event.current.mousePosition;
if ((this.mSamplesImageRect.Contains(mousePosition) || this.mSamplesHeaderRect.Contains(mousePosition)) || this.mSamplesDescriptionRect.Contains(mousePosition))
{
//LuaBinding.Binding();
}
else if ((this.mDocImageRect.Contains(mousePosition) || this.mDocHeaderRect.Contains(mousePosition)) || this.mDocDescriptionRect.Contains(mousePosition))
{
if (Application.platform == RuntimePlatform.WindowsEditor) {
//Packager.BuildWindowsResource();
}
if (Application.platform == RuntimePlatform.OSXEditor) {
//Packager.BuildiPhoneResource();
}
}
else if ((this.mVideoImageRect.Contains(mousePosition) || this.mVideoHeaderRect.Contains(mousePosition)) || this.mVideoDescriptionRect.Contains(mousePosition))
{
//LuaBinding.ClearLuaBinder();
}
else if ((this.mForumImageRect.Contains(mousePosition) || this.mForumHeaderRect.Contains(mousePosition)) || this.mForumDescriptionRect.Contains(mousePosition))
{
//LuaBinding.EncodeLuaFile();
}
else if ((this.mContactImageRect.Contains(mousePosition) || this.mContactHeaderRect.Contains(mousePosition)) || this.mContactDescriptionRect.Contains(mousePosition))
{
Application.OpenURL("path_to_url");
}
}
}
[UnityEditor.MenuItem("LuaFramework/Welcome Screen", false, 1)]
public static void ShowWindow()
{
WelcomeScreen window = EditorWindow.GetWindow<WelcomeScreen>(true, "Welcome to LuaFramework");
window.minSize = window.maxSize = new Vector2(410f, 410f);
UnityEngine.Object.DontDestroyOnLoad(window);
}
}
```
|
```sqlpl
create table SYS_SERVER (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
--
NAME varchar(255),
IS_RUNNING boolean,
DATA text,
--
primary key (ID)
)^
create unique index IDX_SYS_SERVER_UNIQ_NAME on SYS_SERVER (NAME)^
your_sha256_hash--------------------------------------------
create table SYS_CONFIG (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
--
NAME varchar(255) not null,
VALUE_ text not null,
--
primary key (ID)
)^
create unique index IDX_SYS_CONFIG_UNIQ_NAME on SYS_CONFIG (NAME)^
your_sha256_hash--------------------------------------------
create table SYS_FILE (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
NAME varchar(500) not null,
EXT varchar(20),
FILE_SIZE bigint,
CREATE_DATE timestamp,
--
primary key (ID)
)^
your_sha256_hash--------------------------------------------
create table SYS_LOCK_CONFIG (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
--
NAME varchar(100),
TIMEOUT_SEC integer,
--
primary key (ID)
)^
your_sha256_hash--------------------------------------------
create table SYS_ENTITY_STATISTICS (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
--
NAME varchar(50),
INSTANCE_COUNT bigint,
FETCH_UI integer,
MAX_FETCH_UI integer,
LAZY_COLLECTION_THRESHOLD integer,
LOOKUP_SCREEN_THRESHOLD integer,
--
primary key (ID)
)^
create unique index IDX_SYS_ENTITY_STATISTICS_UNIQ_NAME on SYS_ENTITY_STATISTICS (NAME)^
your_sha256_hash--------------------------------------------
create table SYS_SCHEDULED_TASK (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
DEFINED_BY varchar(1) default 'B',
CLASS_NAME varchar(500),
SCRIPT_NAME varchar(500),
BEAN_NAME varchar(50),
METHOD_NAME varchar(50),
METHOD_PARAMS varchar(4000),
USER_NAME varchar(50),
IS_SINGLETON boolean,
IS_ACTIVE boolean,
PERIOD_ integer,
TIMEOUT integer,
START_DATE timestamp,
TIME_FRAME integer,
START_DELAY integer,
PERMITTED_SERVERS varchar(4096),
LOG_START boolean,
LOG_FINISH boolean,
LAST_START_TIME timestamp with time zone,
LAST_START_SERVER varchar(512),
DESCRIPTION varchar(1000),
CRON varchar(100),
SCHEDULING_TYPE varchar(1) default 'P',
--
primary key (ID)
)^
your_sha256_hash--------------------------------------------
create table SYS_SCHEDULED_EXECUTION (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
TASK_ID uuid,
SERVER varchar(512),
START_TIME timestamp with time zone,
FINISH_TIME timestamp with time zone,
RESULT text,
--
primary key (ID),
constraint SYS_SCHEDULED_EXECUTION_TASK foreign key (TASK_ID) references SYS_SCHEDULED_TASK(ID)
)^
create index IDX_SYS_SCHEDULED_EXECUTION_TASK_START_TIME on SYS_SCHEDULED_EXECUTION (TASK_ID, START_TIME)^
create index IDX_SYS_SCHEDULED_EXECUTION_TASK_FINISH_TIME on SYS_SCHEDULED_EXECUTION (TASK_ID, FINISH_TIME)^
your_sha256_hash--------------------------------------------
create table SEC_ROLE (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
NAME varchar(255) not null,
LOC_NAME varchar(255),
DESCRIPTION varchar(1000),
IS_DEFAULT_ROLE boolean,
ROLE_TYPE integer,
SECURITY_SCOPE varchar(255),
--
primary key (ID)
)^
create unique index IDX_SEC_ROLE_UNIQ_NAME on SEC_ROLE (NAME) where DELETE_TS is null and SYS_TENANT_ID is null^
create unique index IDX_SEC_ROLE_UNIQ_NAME_SYS_TENANT_ID_NN on SEC_ROLE (NAME, SYS_TENANT_ID)
where DELETE_TS is null and SYS_TENANT_ID is not null^
your_sha256_hash--------------------------------------------
create table SEC_GROUP (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
NAME varchar(255) not null,
PARENT_ID uuid,
--
primary key (ID),
constraint SEC_GROUP_PARENT foreign key (PARENT_ID) references SEC_GROUP(ID)
)^
create unique index IDX_SEC_GROUP_UNIQ_NAME on SEC_GROUP (NAME) where DELETE_TS is null and SYS_TENANT_ID is null^
create unique index IDX_SEC_GROUP_UNIQ_NAME_SYS_TENANT_ID_NN on SEC_GROUP (NAME, SYS_TENANT_ID)
where DELETE_TS is null and SYS_TENANT_ID is not null^
your_sha256_hash--------------------------------------------
create table SEC_GROUP_HIERARCHY (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
GROUP_ID uuid,
PARENT_ID uuid,
HIERARCHY_LEVEL integer,
--
primary key (ID),
constraint SEC_GROUP_HIERARCHY_GROUP foreign key (GROUP_ID) references SEC_GROUP(ID),
constraint SEC_GROUP_HIERARCHY_PARENT foreign key (PARENT_ID) references SEC_GROUP(ID)
)^
your_sha256_hash--------------------------------------------
create table SEC_USER (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
LOGIN varchar(50) not null,
LOGIN_LC varchar(50) not null,
PASSWORD varchar(255),
PASSWORD_ENCRYPTION varchar(50),
NAME varchar(255),
FIRST_NAME varchar(255),
LAST_NAME varchar(255),
MIDDLE_NAME varchar(255),
POSITION_ varchar(255),
EMAIL varchar(100),
LANGUAGE_ varchar(20),
TIME_ZONE varchar(50),
TIME_ZONE_AUTO boolean,
ACTIVE boolean,
GROUP_ID uuid,
GROUP_NAMES varchar(255),
IP_MASK varchar(200),
CHANGE_PASSWORD_AT_LOGON boolean,
--
primary key (ID),
constraint SEC_USER_GROUP foreign key (GROUP_ID) references SEC_GROUP(ID)
)^
create unique index IDX_SEC_USER_UNIQ_LOGIN on SEC_USER (LOGIN_LC) where DELETE_TS is null and SYS_TENANT_ID is null^
create unique index IDX_SEC_USER_UNIQ_LOGIN_SYS_TENANT_ID_NN on SEC_USER (LOGIN_LC, SYS_TENANT_ID)
where DELETE_TS is null and SYS_TENANT_ID is not null^
your_sha256_hash--------------------------------------------
create table SEC_USER_ROLE (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
--
USER_ID uuid,
ROLE_ID uuid,
ROLE_NAME varchar(50),
--
primary key (ID),
constraint SEC_USER_ROLE_PROFILE foreign key (USER_ID) references SEC_USER(ID),
constraint SEC_USER_ROLE_ROLE foreign key (ROLE_ID) references SEC_ROLE(ID)
)^
create unique index IDX_SEC_USER_ROLE_UNIQ_ROLE on SEC_USER_ROLE (USER_ID, ROLE_ID) where DELETE_TS is null^
your_sha256_hash--------------------------------------------
create table SEC_PERMISSION (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
--
PERMISSION_TYPE integer,
TARGET varchar(100),
VALUE_ integer,
ROLE_ID uuid,
--
primary key (ID),
constraint SEC_PERMISSION_ROLE foreign key (ROLE_ID) references SEC_ROLE(ID)
)^
create unique index IDX_SEC_PERMISSION_UNIQUE on SEC_PERMISSION (ROLE_ID, PERMISSION_TYPE, TARGET) where DELETE_TS is null^
your_sha256_hash--------------------------------------------
create table SEC_CONSTRAINT (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
CODE varchar(255),
CHECK_TYPE varchar(50) default 'db',
OPERATION_TYPE varchar(50) default 'read',
ENTITY_NAME varchar(255) not null,
JOIN_CLAUSE varchar(500),
WHERE_CLAUSE varchar(1000),
GROOVY_SCRIPT text,
FILTER_XML text,
IS_ACTIVE boolean default true,
GROUP_ID uuid,
--
primary key (ID),
constraint SEC_CONSTRAINT_GROUP foreign key (GROUP_ID) references SEC_GROUP(ID)
)^
create index IDX_SEC_CONSTRAINT_GROUP on SEC_CONSTRAINT (GROUP_ID)^
your_sha256_hash--------------------------------------------
create table SEC_LOCALIZED_CONSTRAINT_MSG (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
--
ENTITY_NAME varchar(255) not null,
OPERATION_TYPE varchar(50) not null,
VALUES_ text,
--
primary key (ID)
)^
create unique index IDX_SEC_LOC_CNSTRNT_MSG_UNIQUE
on SEC_LOCALIZED_CONSTRAINT_MSG (ENTITY_NAME, OPERATION_TYPE)
where DELETE_TS is null^
your_sha256_hash--------------------------------------------
create table SEC_SESSION_ATTR (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
NAME varchar(50),
STR_VALUE varchar(1000),
DATATYPE varchar(20),
GROUP_ID uuid,
--
primary key (ID),
constraint SEC_SESSION_ATTR_GROUP foreign key (GROUP_ID) references SEC_GROUP(ID)
)^
create index IDX_SEC_SESSION_ATTR_GROUP on SEC_SESSION_ATTR (GROUP_ID)^
your_sha256_hash--------------------------------------------
create table SEC_USER_SETTING (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
--
USER_ID uuid,
CLIENT_TYPE char(1),
NAME varchar(255),
VALUE_ text,
--
primary key (ID),
constraint SEC_USER_SETTING_USER foreign key (USER_ID) references SEC_USER(ID),
constraint SEC_USER_SETTING_UNIQ unique (USER_ID, NAME, CLIENT_TYPE)
)^
your_sha256_hash--------------------------------------------
create table SEC_USER_SUBSTITUTION (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
USER_ID uuid not null,
SUBSTITUTED_USER_ID uuid not null,
START_DATE timestamp,
END_DATE timestamp,
--
primary key (ID),
constraint FK_SEC_USER_SUBSTITUTION_USER foreign key (USER_ID) references SEC_USER(ID),
constraint FK_SEC_USER_SUBSTITUTION_SUBSTITUTED_USER foreign key (SUBSTITUTED_USER_ID) references SEC_USER(ID)
)^
create index IDX_SEC_USER_SUBSTITUTION_USER on SEC_USER_SUBSTITUTION (USER_ID)^
your_sha256_hash--------------------------------------------
create table SEC_LOGGED_ENTITY (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
--
NAME varchar(100),
AUTO boolean,
MANUAL boolean,
--
primary key (ID),
constraint SEC_LOGGED_ENTITY_UNIQ_NAME unique (NAME)
)^
your_sha256_hash--------------------------------------------
create table SEC_LOGGED_ATTR (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
--
ENTITY_ID uuid,
NAME varchar(255),
--
primary key (ID),
constraint FK_SEC_LOGGED_ATTR_ENTITY foreign key (ENTITY_ID) references SEC_LOGGED_ENTITY(ID),
constraint SEC_LOGGED_ATTR_UNIQ_NAME unique (ENTITY_ID, NAME)
)^
create index IDX_SEC_LOGGED_ATTR_ENTITY on SEC_LOGGED_ATTR (ENTITY_ID)^
your_sha256_hash--------------------------------------------
create table SEC_ENTITY_LOG (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
EVENT_TS timestamp,
USER_ID uuid,
CHANGE_TYPE char(1),
ENTITY varchar(100),
ENTITY_INSTANCE_NAME varchar(1000),
ENTITY_ID uuid,
STRING_ENTITY_ID varchar(255),
INT_ENTITY_ID integer,
LONG_ENTITY_ID bigint,
CHANGES text,
--
primary key (ID),
constraint FK_SEC_ENTITY_LOG_USER foreign key (USER_ID) references SEC_USER(ID)
)^
create index IDX_SEC_ENTITY_LOG_ENTITY_ID on SEC_ENTITY_LOG (ENTITY_ID)^
create index IDX_SEC_ENTITY_LOG_SENTITY_ID on SEC_ENTITY_LOG (STRING_ENTITY_ID)^
create index IDX_SEC_ENTITY_LOG_IENTITY_ID on SEC_ENTITY_LOG (INT_ENTITY_ID)^
create index IDX_SEC_ENTITY_LOG_LENTITY_ID on SEC_ENTITY_LOG (LONG_ENTITY_ID)^
your_sha256_hash--------------------------------------------
create table SEC_FILTER (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
COMPONENT varchar(200),
NAME varchar(255),
CODE varchar(200),
XML text,
USER_ID uuid,
GLOBAL_DEFAULT boolean,
--
primary key (ID),
constraint FK_SEC_FILTER_USER foreign key (USER_ID) references SEC_USER(ID)
)^
create index IDX_SEC_FILTER_COMPONENT_USER on SEC_FILTER (COMPONENT, USER_ID)^
your_sha256_hash--------------------------------------------
create table SYS_FOLDER (
ID uuid,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
FOLDER_TYPE char(1),
PARENT_ID uuid,
NAME varchar(100),
TAB_NAME varchar(100),
SORT_ORDER integer,
--
primary key (ID),
constraint FK_SYS_FOLDER_PARENT foreign key (PARENT_ID) references SYS_FOLDER(ID)
)^
your_sha256_hash--------------------------------------------
create table SYS_APP_FOLDER (
FOLDER_ID uuid,
FILTER_COMPONENT varchar(200),
FILTER_XML varchar(7000),
VISIBILITY_SCRIPT text,
QUANTITY_SCRIPT text,
APPLY_DEFAULT boolean,
--
primary key (FOLDER_ID),
constraint FK_SYS_APP_FOLDER_FOLDER foreign key (FOLDER_ID) references SYS_FOLDER(ID)
)^
your_sha256_hash--------------------------------------------
create table SEC_PRESENTATION (
ID uuid,
CREATE_TS timestamp,
CREATED_BY varchar(50),
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
COMPONENT varchar(200),
NAME varchar(255),
XML varchar(7000),
USER_ID uuid,
IS_AUTO_SAVE boolean,
--
primary key (ID),
constraint SEC_PRESENTATION_USER foreign key (USER_ID) references SEC_USER(ID)
)^
create index IDX_SEC_PRESENTATION_COMPONENT_USER on SEC_PRESENTATION (COMPONENT, USER_ID)^
your_sha256_hash--------------------------------------------
create table SEC_SEARCH_FOLDER (
FOLDER_ID uuid,
FILTER_COMPONENT varchar(200),
FILTER_XML varchar(7000),
USER_ID uuid,
PRESENTATION_ID uuid,
APPLY_DEFAULT boolean,
IS_SET boolean,
ENTITY_TYPE varchar(50),
--
primary key (FOLDER_ID),
constraint FK_SEC_SEARCH_FOLDER_FOLDER foreign key (FOLDER_ID) references SYS_FOLDER(ID),
constraint FK_SEC_SEARCH_FOLDER_USER foreign key (USER_ID) references SEC_USER(ID),
constraint FK_SEC_SEARCH_FOLDER_PRESENTATION foreign key (PRESENTATION_ID)
references SEC_PRESENTATION(ID)
on delete set null
)^
create index IDX_SEC_SEARCH_FOLDER_USER on SEC_SEARCH_FOLDER (USER_ID)^
your_sha256_hash--------------------------------------------
create table SYS_FTS_QUEUE (
ID uuid,
CREATE_TS timestamp,
CREATED_BY varchar(50),
ENTITY_ID uuid,
STRING_ENTITY_ID varchar(255),
INT_ENTITY_ID integer,
LONG_ENTITY_ID bigint,
ENTITY_NAME varchar(200),
CHANGE_TYPE char(1),
SOURCE_HOST varchar(255),
INDEXING_HOST varchar(255),
FAKE boolean,
primary key (ID)
)^
create index IDX_SYS_FTS_QUEUE_IDXHOST_CRTS on SYS_FTS_QUEUE (INDEXING_HOST, CREATE_TS)^
your_sha256_hash--------------------------------------------
create table SEC_SCREEN_HISTORY (
ID uuid,
CREATE_TS timestamp,
CREATED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
USER_ID uuid,
CAPTION varchar(255),
URL TEXT,
ENTITY_ID uuid,
STRING_ENTITY_ID varchar(255),
INT_ENTITY_ID integer,
LONG_ENTITY_ID bigint,
SUBSTITUTED_USER_ID uuid,
--
primary key (ID),
constraint FK_SEC_HISTORY_USER foreign key (USER_ID) references SEC_USER (ID),
constraint FK_SEC_HISTORY_SUBSTITUTED_USER foreign key (SUBSTITUTED_USER_ID) references SEC_USER (ID)
)^
create index IDX_SEC_SCREEN_HISTORY_USER on SEC_SCREEN_HISTORY (USER_ID)^
create index IDX_SEC_SCREEN_HIST_SUB_USER on SEC_SCREEN_HISTORY (SUBSTITUTED_USER_ID)^
create index IDX_SEC_SCREEN_HISTORY_ENTITY_ID on SEC_SCREEN_HISTORY (ENTITY_ID)^
create index IDX_SEC_SCREEN_HISTORY_SENTITY_ID on SEC_SCREEN_HISTORY (STRING_ENTITY_ID)^
create index IDX_SEC_SCREEN_HISTORY_IENTITY_ID on SEC_SCREEN_HISTORY (INT_ENTITY_ID)^
create index IDX_SEC_SCREEN_HISTORY_LENTITY_ID on SEC_SCREEN_HISTORY (LONG_ENTITY_ID)^
your_sha256_hash--------------------------------------------
create table SYS_SENDING_MESSAGE (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp with time zone,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
ADDRESS_TO text,
ADDRESS_CC text,
ADDRESS_BCC text,
ADDRESS_FROM varchar(100),
CAPTION varchar(500),
EMAIL_HEADERS varchar(500),
CONTENT_TEXT text,
CONTENT_TEXT_FILE_ID uuid,
DEADLINE timestamp with time zone,
STATUS int,
DATE_SENT timestamp,
ATTEMPTS_COUNT int,
ATTEMPTS_MADE int,
ATTACHMENTS_NAME text,
BODY_CONTENT_TYPE varchar(50),
--
primary key (ID),
constraint FK_SYS_SENDING_MESSAGE_CONTENT_FILE foreign key (CONTENT_TEXT_FILE_ID) references SYS_FILE(ID)
)^
create index IDX_SYS_SENDING_MESSAGE_STATUS on SYS_SENDING_MESSAGE (STATUS)^
create index IDX_SYS_SENDING_MESSAGE_DATE_SENT on SYS_SENDING_MESSAGE (DATE_SENT)^
create index IDX_SYS_SENDING_MESSAGE_UPDATE_TS on SYS_SENDING_MESSAGE (UPDATE_TS)^
your_sha256_hash--------------------------------------------
create table SYS_SENDING_ATTACHMENT (
ID uuid,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
MESSAGE_ID uuid,
CONTENT bytea,
CONTENT_FILE_ID uuid,
CONTENT_ID varchar(50),
NAME varchar(500),
DISPOSITION varchar(50),
TEXT_ENCODING varchar(50),
--
primary key (ID),
constraint FK_SYS_SENDING_ATTACHMENT_SENDING_MESSAGE foreign key (MESSAGE_ID) references SYS_SENDING_MESSAGE (ID),
constraint FK_SYS_SENDING_ATTACHMENT_CONTENT_FILE foreign key (CONTENT_FILE_ID) references SYS_FILE (ID)
)^
create index SYS_SENDING_ATTACHMENT_MESSAGE_IDX on SYS_SENDING_ATTACHMENT (MESSAGE_ID)^
your_sha256_hash--------------------------------------------
create table SYS_ENTITY_SNAPSHOT (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
ENTITY_META_CLASS varchar(50) not null,
ENTITY_ID uuid,
STRING_ENTITY_ID varchar(255),
INT_ENTITY_ID integer,
LONG_ENTITY_ID bigint,
AUTHOR_ID uuid not null,
VIEW_XML text not null,
SNAPSHOT_XML text not null,
SNAPSHOT_DATE timestamp not null,
--
primary key (ID),
constraint FK_SYS_ENTITY_SNAPSHOT_AUTHOR_ID foreign key (AUTHOR_ID) references SEC_USER(ID)
)^
create index IDX_SYS_ENTITY_SNAPSHOT_ENTITY_ID on SYS_ENTITY_SNAPSHOT (ENTITY_ID)^
create index IDX_SYS_ENTITY_SNAPSHOT_SENTITY_ID on SYS_ENTITY_SNAPSHOT (STRING_ENTITY_ID)^
create index IDX_SYS_ENTITY_SNAPSHOT_IENTITY_ID on SYS_ENTITY_SNAPSHOT (INT_ENTITY_ID)^
create index IDX_SYS_ENTITY_SNAPSHOT_LENTITY_ID on SYS_ENTITY_SNAPSHOT (LONG_ENTITY_ID)^
your_sha256_hash---------------------------------------------
create table SYS_CATEGORY (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
--
NAME varchar(255) not null,
SPECIAL varchar(50),
ENTITY_TYPE varchar(100) not null,
IS_DEFAULT boolean,
DISCRIMINATOR integer,
LOCALE_NAMES varchar(1000),
--
primary key (ID)
)^
create unique index IDX_SYS_CATEGORY_UNIQ_NAME_ENTITY_TYPE on SYS_CATEGORY (NAME, ENTITY_TYPE) where DELETE_TS is null^
your_sha256_hash---------------------------------------------
create table SYS_CATEGORY_ATTR (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
--
CATEGORY_ENTITY_TYPE varchar(4000),
NAME varchar(255),
CODE varchar(255) not null,
DESCRIPTION varchar(1000),
CATEGORY_ID uuid not null,
ENTITY_CLASS varchar(500),
DATA_TYPE varchar(200),
DEFAULT_STRING varchar,
DEFAULT_INT integer,
DEFAULT_DOUBLE numeric(36,6),
DEFAULT_DECIMAL numeric(36,10),
DEFAULT_DATE timestamp,
DEFAULT_DATE_WO_TIME date,
DEFAULT_DATE_IS_CURRENT boolean,
DEFAULT_BOOLEAN boolean,
DEFAULT_ENTITY_VALUE uuid,
DEFAULT_STR_ENTITY_VALUE varchar(255),
DEFAULT_INT_ENTITY_VALUE integer,
DEFAULT_LONG_ENTITY_VALUE bigint,
ENUMERATION varchar(500),
ORDER_NO integer,
SCREEN varchar(255),
REQUIRED boolean,
LOOKUP boolean,
TARGET_SCREENS varchar(4000),
WIDTH varchar(20),
ROWS_COUNT integer,
IS_COLLECTION boolean,
JOIN_CLAUSE varchar(4000),
WHERE_CLAUSE varchar(4000),
FILTER_XML text,
LOCALE_NAMES varchar(1000),
LOCALE_DESCRIPTIONS varchar(4000),
ENUMERATION_LOCALES varchar(5000),
ATTRIBUTE_CONFIGURATION_JSON text,
--
primary key (ID),
constraint SYS_CATEGORY_ATTR_CATEGORY_ID foreign key (CATEGORY_ID) references SYS_CATEGORY(ID)
)^
create index IDX_SYS_CATEGORY_ATTR_CATEGORY on SYS_CATEGORY_ATTR (CATEGORY_ID)^
create unique index IDX_CAT_ATTR_ENT_TYPE_AND_CODE on SYS_CATEGORY_ATTR (CATEGORY_ENTITY_TYPE, CODE) where DELETE_TS is null;
your_sha256_hash---------------------------------------------
create table SYS_ATTR_VALUE (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
--
CATEGORY_ATTR_ID uuid not null,
CODE varchar(255) not null,
ENTITY_ID uuid,
STRING_ENTITY_ID varchar(255),
INT_ENTITY_ID integer,
LONG_ENTITY_ID bigint,
STRING_VALUE varchar,
INTEGER_VALUE integer,
DOUBLE_VALUE numeric(36,6),
DECIMAL_VALUE numeric(36,10),
DATE_VALUE timestamp,
DATE_WO_TIME_VALUE date,
BOOLEAN_VALUE boolean,
ENTITY_VALUE uuid,
STRING_ENTITY_VALUE varchar(255),
INT_ENTITY_VALUE integer,
LONG_ENTITY_VALUE bigint,
PARENT_ID uuid,
--
primary key (ID),
constraint SYS_ATTR_VALUE_CATEGORY_ATTR_ID foreign key (CATEGORY_ATTR_ID) references SYS_CATEGORY_ATTR(ID),
constraint SYS_ATTR_VALUE_ATTR_VALUE_PARENT_ID foreign key (PARENT_ID) references SYS_ATTR_VALUE(ID)
)^
create index IDX_SYS_ATTR_VALUE_ENTITY on SYS_ATTR_VALUE (ENTITY_ID)^
create index IDX_SYS_ATTR_VALUE_SENTITY on SYS_ATTR_VALUE(STRING_ENTITY_ID)^
create index IDX_SYS_ATTR_VALUE_IENTITY on SYS_ATTR_VALUE(INT_ENTITY_ID)^
create index IDX_SYS_ATTR_VALUE_LENTITY on SYS_ATTR_VALUE(LONG_ENTITY_ID)^
your_sha256_hash--------------------------------------------
create table SYS_JMX_INSTANCE (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
--
NODE_NAME varchar(255),
ADDRESS varchar(500) not null,
LOGIN varchar(50) not null,
PASSWORD varchar(255) not null,
--
primary key (ID)
)^
your_sha256_hash--------------------------------------------
create sequence SYS_QUERY_RESULT_SEQ
^
create table SYS_QUERY_RESULT (
ID bigint not null default nextval('SYS_QUERY_RESULT_SEQ'),
SESSION_ID uuid not null,
QUERY_KEY integer not null,
ENTITY_ID uuid,
STRING_ENTITY_ID varchar(255),
INT_ENTITY_ID integer,
LONG_ENTITY_ID bigint,
primary key (ID)
)^
create index IDX_SYS_QUERY_RESULT_ENTITY_SESSION_KEY on SYS_QUERY_RESULT (ENTITY_ID, SESSION_ID, QUERY_KEY)^
create index IDX_SYS_QUERY_RESULT_SENTITY_SESSION_KEY on SYS_QUERY_RESULT (STRING_ENTITY_ID, SESSION_ID, QUERY_KEY)^
create index IDX_SYS_QUERY_RESULT_IENTITY_SESSION_KEY on SYS_QUERY_RESULT (INT_ENTITY_ID, SESSION_ID, QUERY_KEY)^
create index IDX_SYS_QUERY_RESULT_LENTITY_SESSION_KEY on SYS_QUERY_RESULT (LONG_ENTITY_ID, SESSION_ID, QUERY_KEY)^
create index IDX_SYS_QUERY_RESULT_SESSION_KEY on SYS_QUERY_RESULT (SESSION_ID, QUERY_KEY)^
your_sha256_hash----------------------------------------------
create table SEC_REMEMBER_ME (
ID uuid not null,
CREATE_TS timestamp,
CREATED_BY varchar(50),
VERSION integer not null default 1,
--
USER_ID uuid not null,
TOKEN varchar(32) not null,
--
primary key (ID),
constraint FK_SEC_REMEMBER_ME_USER foreign key (USER_ID) references SEC_USER(ID)
)^
create index IDX_SEC_REMEMBER_ME_USER on SEC_REMEMBER_ME(USER_ID)^
create index IDX_SEC_REMEMBER_ME_TOKEN on SEC_REMEMBER_ME(TOKEN)^
your_sha256_hash----------------------------------------------
create table SEC_SESSION_LOG (
ID uuid,
VERSION integer not null default 1,
CREATE_TS timestamp,
CREATED_BY varchar(50),
UPDATE_TS timestamp,
UPDATED_BY varchar(50),
DELETE_TS timestamp,
DELETED_BY varchar(50),
SYS_TENANT_ID varchar(255),
--
SESSION_ID uuid not null,
USER_ID uuid not null,
SUBSTITUTED_USER_ID uuid,
USER_DATA text,
LAST_ACTION integer not null,
CLIENT_INFO varchar(512),
CLIENT_TYPE varchar(10),
ADDRESS varchar(255),
STARTED_TS timestamp,
FINISHED_TS timestamp,
SERVER_ID varchar(128),
--
primary key (ID)
)^
alter table SEC_SESSION_LOG add constraint FK_SEC_SESSION_LOG_USER foreign key (USER_ID) references SEC_USER(ID)^
create index IDX_SEC_SESSION_LOG_USER on SEC_SESSION_LOG (USER_ID)^
alter table SEC_SESSION_LOG add constraint FK_SEC_SESSION_LOG_SUBUSER foreign key (SUBSTITUTED_USER_ID) references SEC_USER(ID)^
create index IDX_SEC_SESSION_LOG_SUBUSER on SEC_SESSION_LOG (SUBSTITUTED_USER_ID)^
create index IDX_SEC_SESSION_LOG_SESSION on SEC_SESSION_LOG (SESSION_ID)^
create index IDX_SESSION_LOG_STARTED_TS on SEC_SESSION_LOG (STARTED_TS DESC)^
your_sha256_hash----------------------------------------------
-- This function is designed only for convenient generation of UUID identifiers in database creation and updating scripts.
-- Do not use it in application. At runtime, all UUID identifiers are generated by the middleware.
create or replace function newid() returns uuid
as 'select md5(random()::text || clock_timestamp()::text)::uuid'
language sql^
your_sha256_hash----------------------------------------------
insert into SEC_GROUP (ID, CREATE_TS, VERSION, NAME, PARENT_ID)
values ('0fa2b1a5-1d68-4d69-9fbd-dff348347f93', now(), 0, 'Company', null)^
insert into SEC_USER (ID, CREATE_TS, VERSION, LOGIN, LOGIN_LC, PASSWORD, PASSWORD_ENCRYPTION, NAME, GROUP_ID, ACTIVE)
values ('60885987-1b61-4247-94c7-dff348347f93', now(), 0, 'admin', 'admin',
'$2a$10$vQx8b8B7jzZ0rQmtuK4YDOKp7nkmUCFjPx6DMT.voPtetNHFOsaOu', 'bcrypt',
'Administrator', '0fa2b1a5-1d68-4d69-9fbd-dff348347f93', true)^
insert into SEC_USER (ID, CREATE_TS, VERSION, LOGIN, LOGIN_LC, PASSWORD, NAME, GROUP_ID, ACTIVE)
values ('a405db59-e674-4f63-8afe-269dda788fe8', now(), 0, 'anonymous', 'anonymous', null,
'Anonymous', '0fa2b1a5-1d68-4d69-9fbd-dff348347f93', true)^
insert into SEC_USER_ROLE (ID, CREATE_TS, VERSION, USER_ID, ROLE_NAME)
values ('6736effb-9dfc-4430-973a-69868606b09c', current_timestamp, 0, '60885987-1b61-4247-94c7-dff348347f93', 'system-full-access')^
insert into SEC_FILTER (ID, CREATE_TS, CREATED_BY, VERSION, COMPONENT, NAME, XML, USER_ID, GLOBAL_DEFAULT)
values ('b61d18cb-e79a-46f3-b16d-eaf4aebb10dd', now(), 'admin', 0, '[sec$User.browse].genericFilter', 'Search by role',
'<?xml version="1.0" encoding="UTF-8"?><filter><and><c name="UrMxpkfMGn" class="com.haulmont.cuba.security.entity.Role" type="CUSTOM" locCaption="Role" entityAlias="u" join="join u.userRoles ur">ur.role.id = :component$genericFilter.UrMxpkfMGn32565<param name="component$genericFilter.UrMxpkfMGn32565">NULL</param></c></and></filter>',
'60885987-1b61-4247-94c7-dff348347f93', false)^
```
|
The Raja of Tanjore is a title pertaining to two distinct South Indian dynasties:
Thanjavur Nayak kingdom (1532–1673)
Thanjavur Maratha kingdom (1674–1855)
|
George Douglas, 1st Earl of Angus (1380–1403) was a Scottish nobleman and peer.
Life
He was born at Tantallon Castle, East Lothian, Scotland. He was the natural-illegitimate son of William Douglas, 1st Earl of Douglas and Margaret Stewart, Dowager Countess of Mar & Countess of Angus and Lady Abernethy in her own right.
His father's wife Margaret had already produced an heir for her Lord in 1358, James, 2nd Earl of Douglas and Mar, who succeeded his father upon his death in 1384.
In 1389, Margaret of Angus relinquished her title in favour of her son, but George did not assume it until his betrothal in 1397 to Princess Mary Stewart, daughter of King Robert III of Scotland. The influence of George's mother must have been considerable - in addition to obtaining a royal bride for George, she persuaded King Robert III to confirm him in his style of Earl of Angus, and also to bestow upon him the lordships of Abernethy, (Perthshire) and Bonkill, (Berwickshire); and "to endow him and his spouse with the justiciary fees of the County of Forfar, to ratify all gifts, entails, and leases made or to be made by his half-sister, Isabel, Countess of Mar, to the said Jorge her brothir".
James 2nd Earl of Douglas, was killed without issue in 1388, at the Battle of Otterburn, and the Earldom of Mar, and all non-entailed Douglas possessions passed to his sister Isabel. The earldom of Douglas passed to a cousin, Archibald the Grim, a natural (illegitimate) son of the Good Sir James Douglas.
The descendants of Archibald the Grim formed the famed Black Douglas line, and those of George formed the longer lived Red Douglas line.
Angus does not appear to have taken much interest in Public life, although his name appears on various minor charters. However, in 1402, he was dispatched under orders of the Duke of Albany, Regent of Scotland, to accompany Murdoch, Earl of Fife and the Earl of Moray to assist Archibald Douglas, 4th Earl of Douglas during his invasion of Northumberland. That incursion ended at the disastrous field of Homildon Hill, where the Scots were routed and all of the above taken prisoner. Both Moray and Angus died of the Plague whilst captive.
Issue
By his wife, Mary Stewart, a daughter of King Robert III, Angus had two children:
William Douglas, 2nd Earl of Angus (1398–1437)
Lady Elizabeth Douglas, married firstly to Sir Alexander Forbes, later 1st Lord Forbes; married secondly to Sir David Hay of Yester.
Mary was to marry a further four times and bear seven more children by three of these husbands. The issue by her second husband, Sir James Kennedy the Younger of Dunure, were the ancestors of the Marquesses of Ailsa; The product of her fourth marriage to William, 1st Lord Graham were the ancestors of the Viscounts of Dundee and the Dukes of Montrose.
References
Sources
Maxwell, Sir Herbert.A History of the House of Douglas. Freemantle, London 1902
Godscroft, David Hume of. Ane Historie of the House and Race of Douglas and Angus. Edinburgh 1646
Brown, Michael. The Black Douglases. Tuckwell press, East Linton, East Lothian 1998
From the Bloody Heart, Oliver Thomson. Sutton, Stroud, Gloucs. 2003
Angus, George Douglas,1st Earl of
Angus, George Douglas, 1st Earl of
Angus, George Douglas, 1st Earl of
Angus, George Douglas, 1st Earl of
Angus, George Douglas, 1st Earl of
Angus
George
14th-century Scottish earls
15th-century Scottish peers
15th-century Scottish military personnel
Prisoners who died in England and Wales detention
|
Frederic Franklyn Van de Water (1890–1968) was an American journalist and writer. He was an honorary sergeant in the New York State Troopers. In 1924, he travelled in the West Indies investigated and reported about rum pirates and Chinese smugglers.
He wrote for Harper's Magazine.
He wrote short stories for pulp fiction magazines such as Collier's.
In the 1949 historical novel The Green Cockade (also published as Catch a Falling Star) Van de Water described the complicated history of Vermont during the American War of Independence - with Ethan Allen waging in effect a double war of independence, both sharing in the common struggle against the British but also struggling to keep Vermont independent against the annexation efforts of New York State.
He was the son of Virginia Terhune and Frederic F. Van de Water Sr.
Books
Glory-hunter; a life of General Custer
Rudyard Kipling's Vermont feud (On the relations of R. Kipling and Beatty Balestier)
Horsemen of the law
Grey riders; the story of the New York state troopers
The Green Cockade/Catch a Falling Star, 1949
- "Wings of the Morning", 1955
- "The Real McCoy" with Publisher's foreword by Stephen Jones
A Home in the Country copyright 1937 published by John Day in association with Reynal & Hitchcock
References
External links
1890 births
1968 deaths
20th-century American journalists
American male journalists
Pulp fiction writers
|
Kang Jin-sung (Hangul: 강진성; born October 19, 1993, in Seoul) is a South Korean infielder for the Doosan Bears of the KBO League.
References
Doosan Bears players
KBO League infielders
South Korean baseball players
1993 births
Living people
|
Fyodorovka (), also spelled Fedorovka, is the name of several inhabited localities in Russia:
Fyodorovka Microdistrict, a microdistrict in Komsomolsky City District and former urban-type settlement in Samara Oblast; merged into the city of Tolyatti in 2006
Fyodorovka, a former urban-type settlement in Chelyabinsk Oblast; since 2004—a part of the city of Chelyabinsk
Fyodorovka, Fyodorovsky District, Republic of Bashkortostan, a rural locality (a selo) in Fyodorovsky District of the Republic of Bashkortostan
Fyodorovka, Ufimsky District, Republic of Bashkortostan, a rural locality (a village) in Ufimsky District of the Republic of Bashkortostan
Fyodorovka, Oryol Oblast, a rural locality (a selo) in Oryol Oblast
References
|
```html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>http::basic_fields::get_chunked_impl</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Beast">
<link rel="up" href="../boost__beast__http__basic_fields.html" title="http::basic_fields">
<link rel="prev" href="get_allocator.html" title="http::basic_fields::get_allocator">
<link rel="next" href="get_keep_alive_impl.html" title="http::basic_fields::get_keep_alive_impl">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="path_to_url">People</a></td>
<td align="center"><a href="path_to_url">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="get_allocator.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost__beast__http__basic_fields.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="get_keep_alive_impl.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="beast.ref.boost__beast__http__basic_fields.get_chunked_impl"></a><a class="link" href="get_chunked_impl.html" title="http::basic_fields::get_chunked_impl">http::basic_fields::get_chunked_impl</a>
</h5></div></div></div>
<p>
<a class="indexterm" name="idp97621824"></a>
Returns the chunked Transfer-Encoding
setting.
</p>
<h6>
<a name="beast.ref.boost__beast__http__basic_fields.get_chunked_impl.h0"></a>
<span class="phrase"><a name="beast.ref.boost__beast__http__basic_fields.get_chunked_impl.synopsis"></a></span><a class="link" href="get_chunked_impl.html#beast.ref.boost__beast__http__basic_fields.get_chunked_impl.synopsis">Synopsis</a>
</h6>
<pre class="programlisting"><span class="keyword">bool</span>
<span class="identifier">get_chunked_impl</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre>
<h6>
<a name="beast.ref.boost__beast__http__basic_fields.get_chunked_impl.h1"></a>
<span class="phrase"><a name="beast.ref.boost__beast__http__basic_fields.get_chunked_impl.description"></a></span><a class="link" href="get_chunked_impl.html#beast.ref.boost__beast__http__basic_fields.get_chunked_impl.description">Description</a>
</h6>
</div>
<table xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
file LICENSE_1_0.txt or copy at <a href="path_to_url" target="_top">path_to_url
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="get_allocator.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost__beast__http__basic_fields.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="get_keep_alive_impl.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
```
|
The St. Stanislaus Bishop and Martyr Roman Catholic Church is a church located at 5818 Dubois Street in Detroit, Michigan. The church was listed on the National Register of Historic Places in 1989.
History
In 1898, the parish of St. Stanislaus was established to relieve the overcrowding in the Polish congregation of at St. Albertus. A church and school were purchased for the parish from the Protestant Bethel Church, and in 1900 a new elementary school was constructed. Reverend F. G. Zella was assigned as the first pastor. However, between 1905-1910 the population of the church doubled, and a new church was desperately needed.
In 1911, work began on a magnificent Baroque church with a lavish Beaux-Arts interior, which was completed in 1913. In 1921, a convent was built for the Felician Sisters who ran the school; seven years later, a high school was constructed. By the late 1940s, St. Stanislaus was the largest Polish parish school in Michigan.
After World War II, the demographics of the neighborhood changed as the Polish Catholics moved out of the city and into the suburbs; in addition, the construction of Interstate 94 split the parish and displaced a number of families. Enrollment in the parish school declined, and the grade school was closed in 1968, the high school in 1973, and the convent demolished soon after.
The parish underwent a resurgence in the late 1970s, but the 1989 reorganization of the Archdiocese of Detroit eliminated the parish. The Archdiocese sold the structure to University of Michigan organist Sam Koontz of Ann Arbor, MI in 1989. The congregation of Promise Land Missionary Baptist Church purchased the church from Koontz's estate in 1995, but lost it through foreclosure in September 2012.
In January 2013, the church was for sale as-is for $79,000. It requires extensive work and several stained glass windows and other architectural elements had previously been removed. The school buildings house the Detroit Academy of Arts & Sciences and were not affected by the foreclosure and sale.
See also
Polish Cathedral style
References
Churches on the National Register of Historic Places in Michigan
Religious organizations established in 1898
Roman Catholic churches completed in 1913
Beaux-Arts architecture in Michigan
Gothic Revival church buildings in Michigan
Renaissance Revival architecture in Michigan
Roman Catholic churches in Detroit
Churches in the Roman Catholic Archdiocese of Detroit
Polish-American culture in Detroit
National Register of Historic Places in Detroit
1898 establishments in Michigan
20th-century Roman Catholic church buildings in the United States
|
```c++
/*
*/
#ifdef __linux__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include "fdtransferClient.h"
#include "log.h"
int FdTransferClient::_peer = -1;
bool FdTransferClient::connectToServer(const char *path) {
closePeer();
_peer = socket(AF_UNIX, SOCK_SEQPACKET, 0);
if (_peer == -1) {
Log::warn("FdTransferClient socket(): %s", strerror(errno));
return false;
}
struct sockaddr_un sun;
socklen_t addrlen;
if (!socketPath(path, &sun, &addrlen)) {
return false;
}
// Do not block for more than 10 seconds when waiting for a response
struct timeval tv = {10, 0};
setsockopt(_peer, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
if (connect(_peer, (const struct sockaddr *)&sun, addrlen) == -1) {
Log::warn("FdTransferClient connect(): %s", strerror(errno));
return false;
}
return true;
}
int FdTransferClient::requestPerfFd(int *tid, struct perf_event_attr *attr) {
struct perf_fd_request request;
request.header.type = PERF_FD;
request.tid = *tid;
memcpy(&request.attr, attr, sizeof(request.attr));
if (RESTARTABLE(send(_peer, &request, sizeof(request), 0)) != sizeof(request)) {
Log::warn("FdTransferClient send(): %s", strerror(errno));
return -1;
}
struct perf_fd_response resp;
int fd = recvFd(request.header.type, &resp.header, sizeof(resp));
if (fd == -1) {
// Update errno for our caller.
errno = resp.header.error;
} else {
// Update the TID of createForThread, in case the multiple threads' requests got mixed up and we're
// now handling the response destined to another. It's alright - the other thread(s) will finish the
// handling of our TID perf fd.
*tid = resp.tid;
}
return fd;
}
int FdTransferClient::requestKallsymsFd() {
struct fd_request request;
request.type = KALLSYMS_FD;
if (RESTARTABLE(send(_peer, &request, sizeof(request), 0)) != sizeof(request)) {
Log::warn("FdTransferClient send(): %s", strerror(errno));
return -1;
}
struct fd_response resp;
int fd = recvFd(request.type, &resp, sizeof(resp));
if (fd == -1) {
errno = resp.error;
}
return fd;
}
int FdTransferClient::recvFd(unsigned int type, struct fd_response *resp, size_t resp_size) {
struct msghdr msg = {0};
struct iovec iov[1];
iov[0].iov_base = resp;
iov[0].iov_len = resp_size;
msg.msg_iov = iov;
msg.msg_iovlen = ARRAY_SIZE(iov);
int newfd;
union {
char buf[CMSG_SPACE(sizeof(newfd))];
struct cmsghdr align;
} u;
msg.msg_control = u.buf;
msg.msg_controllen = sizeof(u.buf);
ssize_t ret = RESTARTABLE(recvmsg(_peer, &msg, 0));
if (ret < 0) {
Log::warn("FdTransferClient recvmsg(): %s", strerror(errno));
return -1;
}
if (resp->type != type) {
Log::warn("FdTransferClient recvmsg(): bad response type");
return -1;
}
if (resp->error == 0) {
struct cmsghdr *cmptr = CMSG_FIRSTHDR(&msg);
if (cmptr != NULL && cmptr->cmsg_len == CMSG_LEN(sizeof(newfd))
&& cmptr->cmsg_level == SOL_SOCKET && cmptr->cmsg_type == SCM_RIGHTS) {
newfd = *((int*)CMSG_DATA(cmptr));
} else {
Log::warn("FdTransferClient recvmsg(): unexpected response with no SCM_RIGHTS: %s", strerror(errno));
newfd = -1;
}
} else {
newfd = -1;
}
return newfd;
}
#endif // __linux__
```
|
```html
<!DOCTYPE html>
<html lang="en-US">
<head>
<meta http-equiv="X-UA-Compatible" content="IE=10.000"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"/>
<meta http-equiv="content-type" content="text/html;charset=UTF-8" />
<meta http-equiv="cache-control" content="no-cache,no-store"/>
<meta http-equiv="pragma" content="no-cache"/>
<meta http-equiv="expires" content="-1"/>
<meta name='mswebdialog-title' content='Connecting to Example Australia'/>
<title>RSA SecurID Authentication</title>
</head>
<body dir="ltr" class="body">
<div id="noScript" style="position:static; width:100%; height:100%; z-index:100">
<h1>JavaScript required</h1>
<p>JavaScript is required. This web browser does not support JavaScript or JavaScript in this web browser is not enabled.</p>
<p>To find out if your web browser supports JavaScript or to enable JavaScript, see web browser help.</p>
</div>
<script type="text/javascript" language="JavaScript">
document.getElementById("noScript").style.display = "none";
</script>
<div id="fullPage">
<div id="brandingWrapper" class="float">
<div id="branding"></div>
</div>
<div id="contentWrapper" class="float">
<div id="content">
<div id="header">
<img class="logoImage" src="/adfs/portal/logo/logo.png?id=your_sha256_hash alt="Example"/>
</div>
<div id="workArea">
<div id="authArea" class="groupMargin">
<div class='fieldMargin bigText'>Welcome EXAMPLE\test123</div><div class='groupMargin'>For security reasons, we require additional information to verify your account</div>
<div class='groupMargin'><div id="loginArea">
<form method="post" id="passcodeForm" autocomplete="off" onsubmit="return validateForm(this)">
<!-- These inputs are required by the presentation framework. Do not modify or remove -->
<input id="authMethod" type="hidden" name="AuthMethod" value="SecurIDAuthentication" />
<input id="context" type="hidden" name="Context" value="<EncryptedData Type="path_to_url#Content" xmlns="path_to_url#"><EncryptionMethod Algorithm="path_to_url#aes256-cbc" /><KeyInfo xmlns="path_to_url#"><EncryptedKey xmlns="path_to_url#"><EncryptionMethod Algorithm="path_to_url#rsa-1_5" /><KeyInfo xmlns="path_to_url#"><KeyName>A87E278695EAC336FF24CF047B3E6B5AC1E7510D</KeyName></KeyInfo><CipherData><CipherValue>i2oZON1eIEibLY9OHLI6HSy1FE7KhQ62qeLd4M+WsjIJP4zSFu5Z9ltp1Yi0+hSrWwyFbQkh+PqkyD3s9Nxb8QbwksDbRFvEb6mLJD+your_sha512_hash+Wn7CL91ezAp+UyHyegogWNrnraigIeR8zHGE+9ZE2GFj+955/qVjUoaMMxfeVVhRPh8CKto4Q0W5FQRlVJ/your_sha256_hash8Vq+w==</CipherValue></CipherData></EncryptedKey></KeyInfo><CipherData><CipherValue>tCR22fIiAMlXPz0SRbqjsegTg5Pi8BQSH83ELDlmbcMVVm/7AY6udDrzFCTWN+eODjY9Nsr5X7N9xJk+QteVKwjW/WR6ATCD8bQOp8PfWAs7Ih4g/f6Ns/JD27Q7YFQZVbr6OdxRfRZf3syfrxr5Rkks1vC99WFiQEzCqsLVPnktLkiN+your_sha256_hashaqbkPsTmWG9LHFWGcHfvSvyHiR3DvoKpejEcpo7/icEk93HHYeXbGSrafnmE+XM1dKsqH6pmmiIbtyour_sha512_hash+kI9KLiwk2AxBARIkIMgogSkWhZuuPKT+e+g/LpC3GzkotKdny3lPyClpiXPyqGQY7tjY005SVSD78iyA1CmUlMmJIEOEgNrBzZP+your_sha256_hashZZqomQBSyDK89Ld04/+YTl4aiC5+your_sha512_hash+your_sha512_hash+s6DxJhdHXF2iAHe9jFQ==</CipherValue></CipherData><Signature xmlns="path_to_url#"><SignedInfo><CanonicalizationMethod Algorithm="path_to_url /><SignatureMethod Algorithm="path_to_url#rsa-sha1" /><Reference URI=""><Transforms><Transform Algorithm="path_to_url#enveloped-signature" /></Transforms><DigestMethod Algorithm="path_to_url#sha1" /><DigestValue>v7au2Y4id9OukyDScJXdmyNJfcM=</DigestValue></Reference></SignedInfo><SignatureValue>your_sha256_hashnxq/SmlTUQRvD3sELYKBTifLI2T8MnnEoZvyUaMUboEKbx/rYzH2PaT25QDWrRVGf3Xw5T9/xL3C7Bq5UxV5NiaRF6EwgmMU32VulZFbcti9kxWLMN/ZqmwEyour_sha512_hashPZ+y+75cWdLROIbzu7xE0npqJjmCgNmN6xcp2YYWYlTQiJda/w6BZ1ePkIJLtmBcv1+KSfcQ==</SignatureValue><KeyInfo><KeyName>266CC02539F6BE76558C0FDEE89BAB5E0F0C12ED</KeyName></KeyInfo></Signature></EncryptedData>" />
<!-- End inputs are required by the presentation framework. -->
<div class="groupMargin">
Enter your RSA SecurID passcode.
</div>
<div class="fieldMargin error smallText">
<label id="errorText" for=""></label>
</div>
<div>
<input id="passcodeInput" name="Passcode" type="password" value="" class="text fullWidth" placeholder="Passcode" tabindex="1" autocomplete="off" autofocus="" />
</div>
<div class="submitMargin">
<input id="submitButton" type="submit" name="Submit" tabindex="2" value="Submit" />
<img class="floatReverse" style="padding:6px 0px 6px 0px" width="90" height="18" alt="RSA logo" src="data:image/gif;base64,R0lGODlhWgASAOZ+AP7x8vBHVvFWY/7y8/zh4+whMvzW2v3s7e0lNv3r7P/9/e0vP/qyour_sha512_hash/WOl/R6hPWKk/ehqO0nOO4yQ+89TPm7wP/6your_sha512_hash/your_sha512_hash+44SPJpdfWHke4xQvivtfm8wfBQXvekq/Nyfe8your_sha512_hash/rFyfvT1u9AUPaaou0uP/m2vPFYZuweMAAAAP///wAAACH/your_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashb29sPSJBZG9iZSBQaG90b3Nob3AgQ0MgMjAxNSAoTWFjaW50b3NoKSI+your_sha256_hashyour_sha256_hashyour_sha256_hashyour_sha256_hashPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PgH//v38+/r5+your_sha256_hashTkpGQj46NjIuKiYiHhoWEg4KBgH9+your_sha256_hashTUxLSklIR0ZFRENCQUA/your_sha256_hashDg0MCwoJCAcGBQQDAgEAACH5BAEAAH4ALAAAAABaABIAAAf/your_sha256_hashyour_sha256_hashFHxRHLqH2ZnX54bfgt0nfByM2+yC59OD98bEyour_sha512_hash+fP4/your_sha256_hashDqE9nznoB0abjxlQInzXyUO60wloIAR8swiZlY+your_sha256_hash0QTwj9EDACUQcBVzrLnk27NqRAADs=" />
</div>
</form>
</div>
</div> <div id="authOptions">
<form id="options" method="post" action="path_to_url">
<script type="text/javascript">
function SelectOption(option) {
var i = document.getElementById('optionSelection');
i.value = option;
document.forms['options'].submit();
return false;
}
</script>
<input id="optionSelection" type="hidden" name="AuthMethod" />
<div class='groupMargin'></div>
</form>
</div>
</div>
</div>
<div id="footerPlaceholder"></div>
</div>
<div id="footer">
<div id="footerLinks" class="floatReverse">
<div><span id="copyright">© 2013 Microsoft</span></div>
</div>
</div>
</div>
</div>
</body>
</html>
```
|
```chuck
/*++
version 3. Alternative licensing terms are available. Contact
info@minocacorp.com for details. See the LICENSE file at the root of this
project for complete licensing information.
Module Name:
install.ck
Abstract:
This module defines the setup configuration data for installing Minoca
OS.
Author:
Evan Green 21-Oct-2016
Environment:
Setup
--*/
from msetup import arch, plat;
//
// Constants
//
var KILOBYTE = 1024;
var MEGABYTE = KILOBYTE * 1024;
var GIGABYTE = MEGABYTE * 1024;
var TERABYTE = GIGABYTE * 1024;
var PETABYTE = TERABYTE * 1024;
var EXABYTE = PETABYTE * 1024;
var EFI_DEFAULT_APP;
if (arch == "x86") {
EFI_DEFAULT_APP = "BOOTIA32.EFI";
} else if (arch == "x64") {
EFI_DEFAULT_APP = "BOOTX64.EFI";
} else if ((arch == "armv7") || (arch == "armv6")) {
EFI_DEFAULT_APP = "BOOTARM.EFI";
}
var PARTITION_FORMAT_NONE = 1;
var PARTITION_FORMAT_MBR = 2;
var PARTITION_FORMAT_GPT = 3;
var PARTITION_TYPE_EFI_SYSTEM =
"\x28\x73\x2A\xC1\x1F\xF8\xD2\x11\xBA\x4B\x00\xA0\xC9\x3E\xC9\x3B";
var PARTITION_TYPE_MINOCA =
"\xCC\x07\xA3\xCE\xBD\x78\x40\x6E\x81\x62\x60\x20\xAF\xB8\x8D\x17";
var PARTITION_ID_DOS_FAT12 = 0x01;
var PARTITION_ID_PRIMARY_FAT16 = 0x04;
var PARTITION_ID_FAT32 = 0x0B;
var PARTITION_ID_FAT32_LBA = 0x0C;
var PARTITION_ID_EFI_GPT = 0xEE;
var PARTITION_ID_MINOCA = 0x6B;
//
// Path configuration
//
//
// All of the source files are located inside of a directory rather than
// directly at the root because some file systems have a limited number of
// entries in the root directory (FAT12/16).
//
var SourceDir = "bin/";
var SystemRoot = "minoca/";
var SystemDirName = "system/";
var SystemDir = SystemRoot + SystemDirName;
var SystemConfigDir = SystemRoot + "config/";
var DriversDir = SystemRoot + "drivers/";
var EfiBootDir = "EFI/BOOT/";
var EfiMinocaDir = "EFI/MINOCA/";
var LoaderPathEfi = SystemDirName + "loadefi";
var LoaderPathPcat = SystemDirName + "loader";
var KernelPath = SystemDirName + "kernel";
//
// File lists
//
var DriverFiles = [
"acpi.drv",
"ehci.drv",
"fat.drv",
"net80211.drv",
"netcore.drv",
"null.drv",
"onering.drv",
"part.drv",
"pci.drv",
"rtlw81xx.drv",
"rtlw8188eufw.bin",
"rtlw8188cufwUMC.bin",
"rtlw8192cufw.bin",
"ser16550.drv",
"sd.drv",
"smsc95xx.drv",
"sound.drv",
"special.drv",
"usbcomp.drv",
"usbcore.drv",
"usbhid.drv",
"usbhub.drv",
"usbkbd.drv",
"usbmass.drv",
"usbmouse.drv",
"usrinput.drv",
"videocon.drv",
];
if ((arch == "x86") || (arch == "x64")) {
DriverFiles += [
"ahci.drv",
"ata.drv",
"atl1c.drv",
"dwceth.drv",
"e100.drv",
"e1000.drv",
"i8042.drv",
"intelhda.drv",
"rtl81xx.drv",
"uhci.drv",
"pcnet32.drv",
];
} else if ((arch == "armv7") || (arch == "armv6")) {
DriverFiles += [
"dma.drv",
"elani2c.drv",
"gpio.drv",
"spb.drv",
];
}
var BootDrivers = [
"acpi.drv",
"fat.drv",
"null.drv",
"part.drv",
"special.drv",
"videocon.drv",
];
if ((arch == "x86") || (arch == "x64")) {
BootDrivers += [
"ahci.drv",
"ata.drv",
"pci.drv",
"ehci.drv",
"usbcomp.drv",
"usbhub.drv",
"usbmass.drv",
"sd.drv",
];
}
var SystemConfigFiles = [
"dev2drv.set",
"devmap.set",
"init.set",
"init.sh",
];
var SystemFiles = [
"kernel",
"loadefi",
"bootmefi.efi",
"libminocaos.so.1",
];
var SystemFilesX86Pcat = [
"mbr.bin",
"fatboot.bin",
"bootman.bin",
"loader",
];
//
// Copy commands
//
var DriversCopy = {
"Destination": DriversDir,
"Source": SourceDir,
"SourceVolume": 0,
"Files": DriverFiles
};
var SystemCopy = {
"Destination": SystemDir,
"Source": SourceDir,
"SourceVolume": 0,
"Files": SystemFiles
};
var SystemConfigCopy = {
"Destination": SystemConfigDir,
"Source": SourceDir,
"SourceVolume": 0,
"Files": SystemConfigFiles
};
var BootmefiCopy = {
"Destination": EfiBootDir,
"Source": SourceDir + "bootmefi.efi",
"SourceVolume": 0,
"Update": true,
};
var BootmefiBackupCopy = {
"Destination": EfiBootDir + "bootmefi.efi",
"Source": SourceDir + "bootmefi.efi",
"SourceVolume": 0,
};
var UserAppsCopy = {
"Destination": "/apps/",
"Source": SourceDir + "apps/",
"SourceVolume": 0,
"Optional": true
};
var UserSkelCopy = {
"Destination": "/apps/",
"Source": SourceDir + "skel/",
"SourceVolume": 0,
};
var TotalBootCopy = [BootmefiCopy, BootmefiBackupCopy];
var TotalCopy = [
DriversCopy,
SystemCopy,
SystemConfigCopy,
UserSkelCopy,
UserAppsCopy
];
//
// Partition descriptions
//
var BootPartition = {
"Index": 0,
"Size": 10 * MEGABYTE,
"PartitionType": PARTITION_TYPE_EFI_SYSTEM,
"MbrType": PARTITION_ID_PRIMARY_FAT16,
"Files": TotalBootCopy,
"Attributes": 0,
"Alignment": 4 * KILOBYTE,
"Flags": {
"Boot": true,
"System": false,
"CompatibilityMode": true,
"WriteVbrLba": false,
"MergeVbr": false,
},
};
var SystemPartition = {
"Index": 1,
"Size": -1,
"PartitionType": PARTITION_TYPE_MINOCA,
"MbrType": PARTITION_ID_MINOCA,
"Files": TotalCopy,
"Attributes": 0,
"Alignment": 4 * KILOBYTE,
"Flags": {
"Boot": false,
"System": true,
"CompatibilityMode": false,
"WriteVbrLba": false,
"MergeVbr": false,
},
};
var Partitions = [BootPartition, SystemPartition];
var DiskData = {
"Format": PARTITION_FORMAT_GPT,
"Partitions": Partitions
};
//
// Boot entry settings
//
var BootEntry = {
"Name": "Minoca OS",
"LoaderArguments": "",
"KernelArguments": "",
"LoaderPath": LoaderPathEfi,
"KernelPath": KernelPath,
"SystemPath": SystemRoot,
"Flags": {
"Debug": false,
"BootDebug": false,
},
"DebugDevice": 0,
};
var BootConfiguration = {
"Timeout": 0,
"DataPath": EfiMinocaDir + "bootconf",
"BootEntries": [BootEntry]
};
//
// Driver database configuration
//
var DriverDb = {
"BootDrivers": BootDrivers,
"BootDriversPath": SystemConfigDir + "bootdrv.set"
};
//
// Final settings compilation
//
var Settings = {
"Disk": DiskData,
"BootConfiguration": BootConfiguration,
"DriverDb": DriverDb
};
//
// Individual platform configurations are defined below. Please try to keep
// these in alphabetical order.
//
//
// BeagleBone Black configuration
//
if (plat == "beagleboneblack") {
DriversCopy["Files"] += [
"am3eth.drv",
"am3i2c.drv",
"am3soc.drv",
"am3usb.drv",
"edma3.drv",
"sdomap4.drv",
"tps65217.drv",
];
DriverDb["BootDrivers"] += [
"am3soc.drv",
"edma3.drv",
"sdomap4.drv",
];
var BboneFirmwareFiles = [
"bbonefw",
"bbonemlo",
];
//
// Copy the firmware to the system partition for recovery if needed.
//
var BboneFirmwareSystemCopy = {
"Destination": SystemDir + "bbone/",
"Source": SourceDir,
"SourceVolume": 0,
"Files": BboneFirmwareFiles
};
//
// Copy the firmware to the boot partition.
//
var BboneFirmwareCopy = {
"Destination": "/bbonefw",
"Source": SourceDir + "bbonefw",
"SourceVolume": 0,
};
TotalCopy.append(BboneFirmwareSystemCopy);
TotalBootCopy.append(BboneFirmwareCopy);
//
// Set the MBR file.
//
var BboneMloCopy = {
"Offset": 0,
"Source": SourceDir + "bbonemlo",
"SourceVolume": 0,
};
DiskData["Mbr"] = BboneMloCopy;
DiskData["Format"] = PARTITION_FORMAT_MBR;
BootPartition["Alignment"] = 1 * MEGABYTE;
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
}
//
// Galileo configuration
//
if (plat == "galileo") {
DriversCopy["Files"] += [
"qrkhostb.drv",
];
DriverDb["BootDrivers"] += [
"qrkhostb.drv",
];
DiskData["Format"] = PARTITION_FORMAT_MBR;
//
// The Galileo uses the second debug device found for debugging.
//
BootEntry["DebugDevice"] = 1;
BootEntry["KernelArguments"] += " ps.env=CONSOLE=/dev/Terminal/Slave2 ";
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
}
//
// ARMv6 install image
//
if (plat == "install-armv6") {
//
// List all the files in the bin directory that are ever installed
// somewhere.
//
var Files = [
"acpi.drv",
"ahci.drv",
"am3eth.drv",
"am3i2c.drv",
"am3soc.drv",
"am3usb.drv",
"ata.drv",
"bc27gpio.drv",
"bc27pwma.drv",
"bootmefi.efi",
"dev2drv.set",
"devmap.set",
"devrem.drv",
"dma.drv",
"dmab2709.drv",
"dwhci.drv",
"ehci.drv",
"elani2c.drv",
"fat.drv",
"goec.drv",
"gpio.drv",
"init.set",
"init.sh",
"install.ck",
"kernel",
"kernel-version",
"libc.so.1",
"libcrypt.so.1",
"libminocaos.so.1",
"loadefi",
"net80211.drv",
"netcore.drv",
"null.drv",
"om4gpio.drv",
"onering.drv",
"part.drv",
"pci.drv",
"pl050.drv",
"ramdisk.drv",
"rk32gpio.drv",
"rk32spi.drv",
"rpifw",
"rtlw81xx.drv",
"rtlw8188eufw.bin",
"rtlw8188cufwUMC.bin",
"rtlw8192cufw.bin",
"sd.drv",
"sdbm2709.drv",
"sdomap4.drv",
"sdrk32xx.drv",
"ser16550.drv",
"smsc91c1.drv",
"smsc95xx.drv",
"sound.drv",
"spb.drv",
"special.drv",
"tps65217.drv",
"usbcomp.drv",
"usbcore.drv",
"usbhid.drv",
"usbhub.drv",
"usbkbd.drv",
"usbmass.drv",
"usbmouse.drv",
"usrinput.drv",
"videocon.drv",
];
Files += [
"skel/",
"rpi/"
];
var FilesCopy = {
"Destination": SourceDir,
"Source": SourceDir,
"SourceVolume": -1,
"Files": Files
};
var AppsCopy = {
"Destination": SourceDir,
"Source": SourceDir,
"SourceVolume": -1,
"Files": ["apps/"],
"Optional": true
};
//
// Create the storage partition.
//
var DataPartition = {
"Index": 0,
"Size": -1,
"Files": [FilesCopy, AppsCopy],
};
DiskData["Partitions"] = [DataPartition];
//
// Perform no actual installation, just create an image that copies the files
// into an image.
//
DiskData["Format"] = PARTITION_FORMAT_NONE;
Settings = {
"Disk": DiskData
};
}
//
// ARMv7 install image
//
if (plat == "install-armv7") {
//
// List all the files in the bin directory that are ever installed
// somewhere.
//
var Files = [
"acpi.drv",
"ahci.drv",
"am3eth.drv",
"am3i2c.drv",
"am3soc.drv",
"am3usb.drv",
"ata.drv",
"bbonefw",
"bbonemlo",
"bc27gpio.drv",
"bc27pwma.drv",
"bootmefi.efi",
"dev2drv.set",
"devmap.set",
"devrem.drv",
"dma.drv",
"dmab2709.drv",
"dwhci.drv",
"edma3.drv",
"ehci.drv",
"elani2c.drv",
"fat.drv",
"goec.drv",
"gpio.drv",
"init.set",
"init.sh",
"install.ck",
"kernel",
"kernel-version",
"libc.so.1",
"libcrypt.so.1",
"libminocaos.so.1",
"loadefi",
"net80211.drv",
"netcore.drv",
"null.drv",
"om4gpio.drv",
"omap4mlo",
"onering.drv",
"pandafw",
"part.drv",
"pci.drv",
"pl050.drv",
"ramdisk.drv",
"rk32gpio.drv",
"rk32spi.drv",
"rk3i2c.drv",
"rk808.drv",
"rpi2fw",
"rtlw81xx.drv",
"rtlw8188eufw.bin",
"rtlw8188cufwUMC.bin",
"rtlw8192cufw.bin",
"sd.drv",
"sdbm2709.drv",
"sdomap4.drv",
"sdrk32xx.drv",
"ser16550.drv",
"smsc91c1.drv",
"smsc95xx.drv",
"sound.drv",
"spb.drv",
"special.drv",
"tps65217.drv",
"usbcomp.drv",
"usbcore.drv",
"usbhid.drv",
"usbhub.drv",
"usbkbd.drv",
"usbmass.drv",
"usbmouse.drv",
"usrinput.drv",
"veyronfw",
"videocon.drv",
];
Files += [
"skel/",
"rpi/"
];
var FilesCopy = {
"Destination": SourceDir,
"Source": SourceDir,
"SourceVolume": -1,
"Files": Files
};
var AppsCopy = {
"Destination": SourceDir,
"Source": SourceDir,
"SourceVolume": -1,
"Files": ["apps/"],
"Optional": true
};
//
// Create the storage partition.
//
var DataPartition = {
"Index": 0,
"Size": -1,
"Files": [FilesCopy, AppsCopy],
};
DiskData["Partitions"] = [DataPartition];
//
// Perform no actual installation, just create an image that copies the files
// into an image.
//
DiskData["Format"] = PARTITION_FORMAT_NONE;
Settings = {
"Disk": DiskData
};
}
//
// x86 install image
//
if ((plat == "install-x86") || (plat == "install-x64")) {
//
// List all the files in the bin directory that are ever installed
// somewhere.
//
var Files = [
"acpi.drv",
"ahci.drv",
"ata.drv",
"atl1c.drv",
"bootman.bin",
"bootmefi.efi",
"dev2drv.set",
"devmap.set",
"devrem.drv",
"dwceth.drv",
"e100.drv",
"e1000.drv",
"ehci.drv",
"fat.drv",
"fatboot.bin",
"i8042.drv",
"init.set",
"init.sh",
"install.ck",
"intelhda.drv",
"kernel",
"kernel-version",
"libc.so.1",
"libcrypt.so.1",
"libminocaos.so.1",
"loader",
"loadefi",
"mbr.bin",
"net80211.drv",
"netcore.drv",
"null.drv",
"onering.drv",
"part.drv",
"pci.drv",
"pcnet32.drv",
"qrkhostb.drv",
"rtl81xx.drv",
"rtlw81xx.drv",
"rtlw8188eufw.bin",
"rtlw8188cufwUMC.bin",
"rtlw8192cufw.bin",
"sd.drv",
"ser16550.drv",
"smsc95xx.drv",
"sound.drv",
"special.drv",
"uhci.drv",
"usbcomp.drv",
"usbcore.drv",
"usbhid.drv",
"usbhub.drv",
"usbkbd.drv",
"usbmass.drv",
"usbmouse.drv",
"usrinput.drv",
"videocon.drv",
];
Files += [
"skel/"
];
var FilesCopy = {
"Destination": SourceDir,
"Source": SourceDir,
"SourceVolume": -1,
"Files": Files
};
var AppsCopy = {
"Destination": SourceDir,
"Source": SourceDir,
"SourceVolume": -1,
"Files": ["apps/"],
"Optional": true
};
//
// Create the storage partition.
//
var DataPartition = {
"Index": 0,
"Size": -1,
"Files": [FilesCopy, AppsCopy],
};
DiskData["Partitions"] = [DataPartition];
//
// Perform no actual installation, just create an image that copies the
// files into an image.
//
DiskData["Format"] = PARTITION_FORMAT_NONE;
Settings = {
"Disk": DiskData
};
}
//
// Integrator/CP RAM disk image
//
if (plat == "integrd") {
DriversCopy["Files"] += [
"ramdisk.drv",
"pl050.drv",
"smsc91c1.drv",
];
DriverDb["BootDrivers"] += [
"ramdisk.drv",
];
//
// Remove apps from the user files since it can be huge. Just add the bare
// minimum.
//
UserAppsCopy["Source"] = "";
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
}
//
// PandaBoard image
//
if ((plat == "panda") || (plat == "panda-es")) {
DriversCopy["Files"] += [
"sdomap4.drv",
"om4gpio.drv",
];
DriverDb["BootDrivers"] += [
"sdomap4.drv",
];
var PandaFirmwareFiles = [
"pandafw",
"omap4mlo",
];
//
// Copy the firmware to the system partition for recovery if needed.
//
var PandaFirmwareSystemCopy = {
"Destination": SystemDir + "panda/",
"Source": SourceDir,
"SourceVolume": 0,
"Files": PandaFirmwareFiles
};
//
// Copy the firmware to the boot partition.
//
var PandaFirmwareCopy = {
"Destination": "/pandafw",
"Source": SourceDir + "pandafw",
"SourceVolume": 0,
};
TotalCopy.append(PandaFirmwareSystemCopy);
TotalBootCopy.append(PandaFirmwareCopy);
//
// Set the MBR file.
//
var PandaMloCopy = {
"Offset": 0,
"Source": SourceDir + "omap4mlo",
"SourceVolume": 0,
};
DiskData["Mbr"] = PandaMloCopy;
DiskData["Format"] = PARTITION_FORMAT_MBR;
BootPartition["Alignment"] = 1 * MEGABYTE;
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
}
//
// Pandaboard USB image
//
if (plat == "panda-usb") {
DriversCopy["Files"] += [
"ramdisk.drv",
"om4gpio.drv",
"sdomap4.drv",
"smsc91c1.drv",
];
DriverDb["BootDrivers"] += [
"ramdisk.drv",
];
//
// Remove apps from the user files since it can be huge. Just add the bare
// minimum.
//
UserAppsCopy["Source"] = "";
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
BootPartition["Size"] = 3 * MEGABYTE;
SystemPartition["Size"] = 20 * MEGABYTE;
}
//
// PC (BIOS) image
//
if ((plat == "pc32") || (plat == "pc64")) {
//
// Copy the firmware to the system partition for recovery if needed.
//
SystemCopy["Files"] += SystemFilesX86Pcat;
//
// Set the MBR file.
//
var MbrCopy = {
"Offset": 0,
"Source": SourceDir + "mbr.bin",
"SourceVolume": 0,
};
DiskData["Mbr"] = MbrCopy;
//
// Set the VBR file.
//
var VbrCopy = {
"Offset": 0,
"Source": SourceDir + "fatboot.bin",
"SourceVolume": 0,
};
BootPartition["Vbr"] = VbrCopy;
BootPartition["Flags"]["MergeVbr"] = true;
//
// Replace the boot files with the boot manager.
//
var BootmanCopy = {
"Destination": "/",
"Source": SourceDir,
"SourceVolume": 0,
"Files": ["bootman.bin"]
};
BootPartition["Files"] = [BootmanCopy];
BootPartition["Alignment"] = 1 * MEGABYTE;
BootPartition["Flags"]["WriteVbrLba"] = true;
BootEntry["LoaderPath"] = LoaderPathPcat;
SystemPartition["Alignment"] = 1 * MEGABYTE;
DiskData["Format"] = PARTITION_FORMAT_MBR;
}
//
// PC (UEFI) image
//
if ((plat == "pc32efi") || (plat == "pc64efi")) {
//
// Add the BIOS files anyway for machines with a BIOS compatibility module.
//
SystemCopy["Files"] += SystemFilesX86Pcat;
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
BootPartition["Alignment"] = 1 * MEGABYTE;
SystemPartition["Alignment"] = 1 * MEGABYTE;
}
//
// PC (tiny) image
//
if ((plat == "pc32-tiny") || (plat == "pc64-tiny")) {
//
// Completely clobber the drivers list with one that fits x86 Qemu
// perfectly.
//
DriversCopy["Files"] = [
"acpi.drv",
"fat.drv",
"netcore.drv",
"null.drv",
"part.drv",
"pci.drv",
"special.drv",
"usrinput.drv",
"videocon.drv",
"ata.drv",
"e100.drv",
"i8042.drv",
];
DriverDb["BootDrivers"] = [
"acpi.drv",
"ata.drv",
"fat.drv",
"null.drv",
"part.drv",
"pci.drv",
"special.drv",
"videocon.drv",
];
//
// Copy the firmware to the system partition for recovery if needed.
//
SystemCopy["Files"] += SystemFilesX86Pcat;
//
// Remove apps from the user files since it can be huge. Just add the bare
// minimum.
//
UserAppsCopy["Source"] = "";
//
// Set the MBR file.
//
var MbrCopy = {
"Offset": 0,
"Source": SourceDir + "mbr.bin",
"SourceVolume": 0,
};
DiskData["Mbr"] = MbrCopy;
//
// Set the VBR file.
//
var VbrCopy = {
"Offset": 0,
"Source": SourceDir + "fatboot.bin",
"SourceVolume": 0,
};
//
// Replace the boot files with the boot manager.
//
var BootmanCopy = {
"Destination": "/",
"Source": SourceDir,
"SourceVolume": 0,
"Files": ["bootman.bin"]
};
var TotalCopies = [BootmanCopy] + SystemPartition["Files"];
BootPartition = {
"Index": 0,
"Size": -1,
"PartitionType": PARTITION_TYPE_MINOCA,
"MbrType": PARTITION_ID_MINOCA,
"Files": TotalCopies,
"Attributes": 0,
"Alignment": 4 * KILOBYTE,
"Vbr": VbrCopy,
"Flags": {
"Boot": true,
"System": true,
"CompatibilityMode": false,
"WriteVbrLba": true,
"MergeVbr": true,
},
};
DiskData["Partitions"] = [BootPartition];
DiskData["Format"] = PARTITION_FORMAT_MBR;
BootEntry["LoaderPath"] = LoaderPathPcat;
BootPartition["Alignment"] = 1 * MEGABYTE;
SystemPartition["Alignment"] = 1 * MEGABYTE;
}
//
// Raspberry Pi 1 image (ARMv6)
//
if (plat == "raspberrypi") {
DriversCopy["Files"] += [
"dwhci.drv",
"dmab2709.drv",
"sdbm2709.drv",
"bc27gpio.drv",
"bc27pwma.drv",
];
DriverDb["BootDrivers"] += [
"dmab2709.drv",
"sdbm2709.drv",
];
var RpiFirmwareBlobFiles = [
"config.txt",
"start.elf",
"fixup.dat",
"bootcode.bin",
"LICENCE.broadcom"
];
//
// Copy the firmware to the system partition for recovery if needed.
//
var RpiFirmwareBlobsSystemCopy = {
"Destination": SystemDir + "rpi/",
"Source": SourceDir + "rpi/",
"SourceVolume": 0,
"Files": RpiFirmwareBlobFiles
};
var RpiFirmwareSystemCopy = {
"Destination": SystemDir + "rpi/rpifw",
"Source": SourceDir + "rpifw",
"SourceVolume": 0
};
//
// Copy the firmware to the boot partition.
//
var RpiFirmwareBlobsCopy = {
"Destination": "/",
"Source": SourceDir + "rpi/",
"SourceVolume": 0,
"Files": RpiFirmwareBlobFiles
};
var RpiFirmwareCopy = {
"Destination": "/rpifw",
"Source": SourceDir + "rpifw",
"SourceVolume": 0,
};
TotalCopy.append(RpiFirmwareBlobsSystemCopy);
TotalCopy.append(RpiFirmwareSystemCopy);
TotalBootCopy.append(RpiFirmwareBlobsCopy);
TotalBootCopy.append(RpiFirmwareCopy);
DiskData["Format"] = PARTITION_FORMAT_MBR;
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
BootPartition["Alignment"] = 1 * MEGABYTE;
BootPartition["Size"] = 20 * MEGABYTE;
}
//
// Raspberry Pi 2 and 3 (32-bit only).
//
if (plat == "raspberrypi2") {
DriversCopy["Files"] += [
"dwhci.drv",
"dmab2709.drv",
"sdbm2709.drv",
"bc27gpio.drv",
"bc27pwma.drv",
];
DriverDb["BootDrivers"] += [
"dmab2709.drv",
"sdbm2709.drv",
];
var RpiFirmwareFiles = [
"config.txt",
"start.elf",
"fixup.dat",
"bootcode.bin",
"LICENCE.broadcom"
];
//
// Copy the firmware to the system partition for recovery if needed.
//
var RpiFirmwareSystemCopy = {
"Destination": SystemDir + "rpi/",
"Source": SourceDir + "rpi/",
"SourceVolume": 0,
"Files": RpiFirmwareFiles
};
var Rpi2FirmwareSystemCopy = {
"Destination": SystemDir + "rpi2/rpifw",
"Source": SourceDir + "rpi2fw",
"SourceVolume": 0,
};
//
// Copy the firmware to the boot partition.
//
var RpiFirmwareCopy = {
"Destination": "/",
"Source": SourceDir + "rpi/",
"SourceVolume": 0,
"Files": RpiFirmwareFiles
};
//
// The config.txt is expecting the name rpifw, so do a special copy and rename
// for Raspberry Pi 2.
//
var Rpi2FirmwareCopy = {
"Destination": "/rpifw",
"Source": SourceDir + "rpi2fw",
"SourceVolume": 0
};
TotalCopy.append(RpiFirmwareSystemCopy);
TotalCopy.append(Rpi2FirmwareSystemCopy);
TotalBootCopy.append(RpiFirmwareCopy);
TotalBootCopy.append(Rpi2FirmwareCopy);
DiskData["Format"] = PARTITION_FORMAT_MBR;
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
BootPartition["Alignment"] = 1 * MEGABYTE;
BootPartition["Size"] = 20 * MEGABYTE;
}
if (plat == "veyron") {
DriversCopy["Files"] += [
"dwhci.drv",
"sdrk32xx.drv",
"rk32spi.drv",
"goec.drv",
"rk32gpio.drv",
"rk3i2c.drv",
"rk808.drv"
];
//
// I2c and the RK808 PMIC are needed to bring up SD, since SD makes voltage
// changes via the PMIC.
//
DriverDb["BootDrivers"] += [
"sdrk32xx.drv",
"rk32gpio.drv",
"rk3i2c.drv",
"rk808.drv"
];
var VeyronFirmwareCopy = {
"Offset": 0,
"Source": SourceDir + "veyronfw",
"SourceVolume": 0
};
//
// Set up the correct partition layout for verified boot, which has a
// firmware partition at the beginning with the raw firmware image in it.
//
var PARTITION_TYPE_VBOOT_FIRMWARE =
"\x5D\x2A\x3A\xFE\x32\x4F\xA7\x41\xb7\x25\xAC\xCC\x32\x85\xA3\x09";
var VeyronFirmwarePartition = {
"Index": 0,
"Size": 1 * MEGABYTE,
"PartitionType": PARTITION_TYPE_VBOOT_FIRMWARE,
"Files": [],
"Attributes": 0x01FF000000000000,
"Vbr": VeyronFirmwareCopy,
"Flags": {
"Boot": false,
"System": false
},
};
BootPartition["Index"] += 1;
SystemPartition["Index"] += 1;
Partitions.append(VeyronFirmwarePartition);
//
// Copy the firmware to the system partition for recovery if needed.
//
var VeyronFirmwareFiles = [
"veyronfw",
];
var VeyronFirmwareSystemCopy = {
"Destination": SystemDir + "veyron/",
"Source": SourceDir,
"SourceVolume": 0,
"Files": VeyronFirmwareFiles
};
TotalCopy.append(VeyronFirmwareSystemCopy);
//
// Set the EFI boot manager name.
//
BootmefiCopy["Destination"] += EFI_DEFAULT_APP;
}
```
|
```ruby
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
require_relative 'shared/accessor'
describe "Struct#size" do
it "is a synonym for length" do
StructClasses::Car.new.size.should == StructClasses::Car.new.length
end
it_behaves_like :struct_accessor, :size
end
```
|
Hudson Bay Industrial Saskatoon, Saskatchewan, is in the Northwest section of the North West Industrial SDA. Now named Hudson Bay Industrial, in the early days of the Saskatoon's history, the area between 56th Street and 60th Street was originally to have been Swastika Park. Until the late 1990s, the area was part of the North Industrial subdivision until the City of Saskatoon redesignated the lands north of 51st Street and south of 60th Street with this new name. Hudson Bay Industrial subdivision consists primarily of industrial and retail development.
Layout
60th Street is the northernmost perimeter, and 51st the southernmost. The streets are incremented numerically from 51st to 60th Street and run east and west. Wanuskewin Road and the CNR mark the eastern boundary. Idylwyld Drive delimits the eastern edge.
History
The road names of this industrial subdivision mainly honour pioneers of Saskatoon.
Retail Sector
There are a number of restaurants serving this industrial area lining 51st Street, some of these are A&W Restaurants, Taco Time, Extreme Pita, Boston Pizza, Wendy's, Tim Hortons to name a few. This arterial retail street also hosts shops such as Peavey Mart.
See also
List of shopping malls in Saskatoon
Recreation
Between Tubby Crescent and English crescent are the Rugby fields
Transportation
Saskatchewan Highway 11, Louis Riel Trail, or Idylwyld Drive connects three main Saskatchewan cities: Regina, Saskatoon and Prince Albert.
City Transit
Saskatoon Transit
References
External links
Neighbourhood Profiles
Saskatoon Neighbourhoods Word Search Puzzle
City of Saskatoon · Departments · Community Services · Community ...
City of Saskatoon · Departments · Community Services · City Planning · ZAM Maps
Populace Spring 2006
Neighbourhoods in Saskatoon
|
The 2011–12 Bulgarian Hockey League season was the 60th season of the Bulgarian Hockey League, the top level of ice hockey in Bulgaria. Three teams participated in the league, and HK Slavia Sofia won the championship.
Regular season
External links
Season on eurohockey.com
Bulgar
Bulgarian Hockey League seasons
Bulg
|
```yaml
subject: "Range"
description: "Range literal a...b (with excluded end)"
focused_on_node: "org.truffleruby.core.range.RangeNodes$RangeLiteralNode"
ruby: |
"a"..."z"
ast: |
RangeNodesFactory$RangeLiteralNodeGen
attributes:
flags = 1
sourceCharIndex = 0
sourceLength = 9
children:
beginNode_ =
StringLiteralNode
attributes:
encoding = UTF-8
flags = 0
sourceCharIndex = 0
sourceLength = 3
tstring = a
endNode_ =
StringLiteralNode
attributes:
encoding = UTF-8
flags = 0
sourceCharIndex = 6
sourceLength = 3
tstring = z
```
|
```go
// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go | go run mkpost.go
// Code generated by the command above; see README.md. DO NOT EDIT.
// +build riscv64,linux
package unix
const (
SizeofPtr = 0x8
SizeofShort = 0x2
SizeofInt = 0x4
SizeofLong = 0x8
SizeofLongLong = 0x8
PathMax = 0x1000
)
type (
_C_short int16
_C_int int32
_C_long int64
_C_long_long int64
)
type Timespec struct {
Sec int64
Nsec int64
}
type Timeval struct {
Sec int64
Usec int64
}
type Timex struct {
Modes uint32
Offset int64
Freq int64
Maxerror int64
Esterror int64
Status int32
Constant int64
Precision int64
Tolerance int64
Time Timeval
Tick int64
Ppsfreq int64
Jitter int64
Shift int32
Stabil int64
Jitcnt int64
Calcnt int64
Errcnt int64
Stbcnt int64
Tai int32
_ [44]byte
}
type Time_t int64
type Tms struct {
Utime int64
Stime int64
Cutime int64
Cstime int64
}
type Utimbuf struct {
Actime int64
Modtime int64
}
type Rusage struct {
Utime Timeval
Stime Timeval
Maxrss int64
Ixrss int64
Idrss int64
Isrss int64
Minflt int64
Majflt int64
Nswap int64
Inblock int64
Oublock int64
Msgsnd int64
Msgrcv int64
Nsignals int64
Nvcsw int64
Nivcsw int64
}
type Rlimit struct {
Cur uint64
Max uint64
}
type _Gid_t uint32
type Stat_t struct {
Dev uint64
Ino uint64
Mode uint32
Nlink uint32
Uid uint32
Gid uint32
Rdev uint64
_ uint64
Size int64
Blksize int32
_ int32
Blocks int64
Atim Timespec
Mtim Timespec
Ctim Timespec
_ [2]int32
}
type StatxTimestamp struct {
Sec int64
Nsec uint32
_ int32
}
type Statx_t struct {
Mask uint32
Blksize uint32
Attributes uint64
Nlink uint32
Uid uint32
Gid uint32
Mode uint16
_ [1]uint16
Ino uint64
Size uint64
Blocks uint64
Attributes_mask uint64
Atime StatxTimestamp
Btime StatxTimestamp
Ctime StatxTimestamp
Mtime StatxTimestamp
Rdev_major uint32
Rdev_minor uint32
Dev_major uint32
Dev_minor uint32
_ [14]uint64
}
type Dirent struct {
Ino uint64
Off int64
Reclen uint16
Type uint8
Name [256]uint8
_ [5]byte
}
type Fsid struct {
Val [2]int32
}
type Flock_t struct {
Type int16
Whence int16
Start int64
Len int64
Pid int32
_ [4]byte
}
type FscryptPolicy struct {
Version uint8
Contents_encryption_mode uint8
Filenames_encryption_mode uint8
Flags uint8
Master_key_descriptor [8]uint8
}
type FscryptKey struct {
Mode uint32
Raw [64]uint8
Size uint32
}
type KeyctlDHParams struct {
Private int32
Prime int32
Base int32
}
const (
FADV_NORMAL = 0x0
FADV_RANDOM = 0x1
FADV_SEQUENTIAL = 0x2
FADV_WILLNEED = 0x3
FADV_DONTNEED = 0x4
FADV_NOREUSE = 0x5
)
type RawSockaddrInet4 struct {
Family uint16
Port uint16
Addr [4]byte /* in_addr */
Zero [8]uint8
}
type RawSockaddrInet6 struct {
Family uint16
Port uint16
Flowinfo uint32
Addr [16]byte /* in6_addr */
Scope_id uint32
}
type RawSockaddrUnix struct {
Family uint16
Path [108]int8
}
type RawSockaddrLinklayer struct {
Family uint16
Protocol uint16
Ifindex int32
Hatype uint16
Pkttype uint8
Halen uint8
Addr [8]uint8
}
type RawSockaddrNetlink struct {
Family uint16
Pad uint16
Pid uint32
Groups uint32
}
type RawSockaddrHCI struct {
Family uint16
Dev uint16
Channel uint16
}
type RawSockaddrL2 struct {
Family uint16
Psm uint16
Bdaddr [6]uint8
Cid uint16
Bdaddr_type uint8
_ [1]byte
}
type RawSockaddrRFCOMM struct {
Family uint16
Bdaddr [6]uint8
Channel uint8
_ [1]byte
}
type RawSockaddrCAN struct {
Family uint16
Ifindex int32
Addr [8]byte
}
type RawSockaddrALG struct {
Family uint16
Type [14]uint8
Feat uint32
Mask uint32
Name [64]uint8
}
type RawSockaddrVM struct {
Family uint16
Reserved1 uint16
Port uint32
Cid uint32
Zero [4]uint8
}
type RawSockaddrXDP struct {
Family uint16
Flags uint16
Ifindex uint32
Queue_id uint32
Shared_umem_fd uint32
}
type RawSockaddrPPPoX [0x1e]byte
type RawSockaddr struct {
Family uint16
Data [14]uint8
}
type RawSockaddrAny struct {
Addr RawSockaddr
Pad [96]uint8
}
type _Socklen uint32
type Linger struct {
Onoff int32
Linger int32
}
type Iovec struct {
Base *byte
Len uint64
}
type IPMreq struct {
Multiaddr [4]byte /* in_addr */
Interface [4]byte /* in_addr */
}
type IPMreqn struct {
Multiaddr [4]byte /* in_addr */
Address [4]byte /* in_addr */
Ifindex int32
}
type IPv6Mreq struct {
Multiaddr [16]byte /* in6_addr */
Interface uint32
}
type PacketMreq struct {
Ifindex int32
Type uint16
Alen uint16
Address [8]uint8
}
type Msghdr struct {
Name *byte
Namelen uint32
Iov *Iovec
Iovlen uint64
Control *byte
Controllen uint64
Flags int32
_ [4]byte
}
type Cmsghdr struct {
Len uint64
Level int32
Type int32
}
type Inet4Pktinfo struct {
Ifindex int32
Spec_dst [4]byte /* in_addr */
Addr [4]byte /* in_addr */
}
type Inet6Pktinfo struct {
Addr [16]byte /* in6_addr */
Ifindex uint32
}
type IPv6MTUInfo struct {
Addr RawSockaddrInet6
Mtu uint32
}
type ICMPv6Filter struct {
Data [8]uint32
}
type Ucred struct {
Pid int32
Uid uint32
Gid uint32
}
type TCPInfo struct {
State uint8
Ca_state uint8
Retransmits uint8
Probes uint8
Backoff uint8
Options uint8
Rto uint32
Ato uint32
Snd_mss uint32
Rcv_mss uint32
Unacked uint32
Sacked uint32
Lost uint32
Retrans uint32
Fackets uint32
Last_data_sent uint32
Last_ack_sent uint32
Last_data_recv uint32
Last_ack_recv uint32
Pmtu uint32
Rcv_ssthresh uint32
Rtt uint32
Rttvar uint32
Snd_ssthresh uint32
Snd_cwnd uint32
Advmss uint32
Reordering uint32
Rcv_rtt uint32
Rcv_space uint32
Total_retrans uint32
}
type CanFilter struct {
Id uint32
Mask uint32
}
const (
SizeofSockaddrInet4 = 0x10
SizeofSockaddrInet6 = 0x1c
SizeofSockaddrAny = 0x70
SizeofSockaddrUnix = 0x6e
SizeofSockaddrLinklayer = 0x14
SizeofSockaddrNetlink = 0xc
SizeofSockaddrHCI = 0x6
SizeofSockaddrL2 = 0xe
SizeofSockaddrRFCOMM = 0xa
SizeofSockaddrCAN = 0x10
SizeofSockaddrALG = 0x58
SizeofSockaddrVM = 0x10
SizeofSockaddrXDP = 0x10
SizeofSockaddrPPPoX = 0x1e
SizeofLinger = 0x8
SizeofIovec = 0x10
SizeofIPMreq = 0x8
SizeofIPMreqn = 0xc
SizeofIPv6Mreq = 0x14
SizeofPacketMreq = 0x10
SizeofMsghdr = 0x38
SizeofCmsghdr = 0x10
SizeofInet4Pktinfo = 0xc
SizeofInet6Pktinfo = 0x14
SizeofIPv6MTUInfo = 0x20
SizeofICMPv6Filter = 0x20
SizeofUcred = 0xc
SizeofTCPInfo = 0x68
SizeofCanFilter = 0x8
)
const (
NDA_UNSPEC = 0x0
NDA_DST = 0x1
NDA_LLADDR = 0x2
NDA_CACHEINFO = 0x3
NDA_PROBES = 0x4
NDA_VLAN = 0x5
NDA_PORT = 0x6
NDA_VNI = 0x7
NDA_IFINDEX = 0x8
NDA_MASTER = 0x9
NDA_LINK_NETNSID = 0xa
NDA_SRC_VNI = 0xb
NTF_USE = 0x1
NTF_SELF = 0x2
NTF_MASTER = 0x4
NTF_PROXY = 0x8
NTF_EXT_LEARNED = 0x10
NTF_OFFLOADED = 0x20
NTF_ROUTER = 0x80
NUD_INCOMPLETE = 0x1
NUD_REACHABLE = 0x2
NUD_STALE = 0x4
NUD_DELAY = 0x8
NUD_PROBE = 0x10
NUD_FAILED = 0x20
NUD_NOARP = 0x40
NUD_PERMANENT = 0x80
NUD_NONE = 0x0
IFA_UNSPEC = 0x0
IFA_ADDRESS = 0x1
IFA_LOCAL = 0x2
IFA_LABEL = 0x3
IFA_BROADCAST = 0x4
IFA_ANYCAST = 0x5
IFA_CACHEINFO = 0x6
IFA_MULTICAST = 0x7
IFA_FLAGS = 0x8
IFA_RT_PRIORITY = 0x9
IFA_TARGET_NETNSID = 0xa
IFLA_UNSPEC = 0x0
IFLA_ADDRESS = 0x1
IFLA_BROADCAST = 0x2
IFLA_IFNAME = 0x3
IFLA_MTU = 0x4
IFLA_LINK = 0x5
IFLA_QDISC = 0x6
IFLA_STATS = 0x7
IFLA_COST = 0x8
IFLA_PRIORITY = 0x9
IFLA_MASTER = 0xa
IFLA_WIRELESS = 0xb
IFLA_PROTINFO = 0xc
IFLA_TXQLEN = 0xd
IFLA_MAP = 0xe
IFLA_WEIGHT = 0xf
IFLA_OPERSTATE = 0x10
IFLA_LINKMODE = 0x11
IFLA_LINKINFO = 0x12
IFLA_NET_NS_PID = 0x13
IFLA_IFALIAS = 0x14
IFLA_NUM_VF = 0x15
IFLA_VFINFO_LIST = 0x16
IFLA_STATS64 = 0x17
IFLA_VF_PORTS = 0x18
IFLA_PORT_SELF = 0x19
IFLA_AF_SPEC = 0x1a
IFLA_GROUP = 0x1b
IFLA_NET_NS_FD = 0x1c
IFLA_EXT_MASK = 0x1d
IFLA_PROMISCUITY = 0x1e
IFLA_NUM_TX_QUEUES = 0x1f
IFLA_NUM_RX_QUEUES = 0x20
IFLA_CARRIER = 0x21
IFLA_PHYS_PORT_ID = 0x22
IFLA_CARRIER_CHANGES = 0x23
IFLA_PHYS_SWITCH_ID = 0x24
IFLA_LINK_NETNSID = 0x25
IFLA_PHYS_PORT_NAME = 0x26
IFLA_PROTO_DOWN = 0x27
IFLA_GSO_MAX_SEGS = 0x28
IFLA_GSO_MAX_SIZE = 0x29
IFLA_PAD = 0x2a
IFLA_XDP = 0x2b
IFLA_EVENT = 0x2c
IFLA_NEW_NETNSID = 0x2d
IFLA_IF_NETNSID = 0x2e
IFLA_TARGET_NETNSID = 0x2e
IFLA_CARRIER_UP_COUNT = 0x2f
IFLA_CARRIER_DOWN_COUNT = 0x30
IFLA_NEW_IFINDEX = 0x31
IFLA_MIN_MTU = 0x32
IFLA_MAX_MTU = 0x33
IFLA_MAX = 0x33
IFLA_INFO_KIND = 0x1
IFLA_INFO_DATA = 0x2
IFLA_INFO_XSTATS = 0x3
IFLA_INFO_SLAVE_KIND = 0x4
IFLA_INFO_SLAVE_DATA = 0x5
RT_SCOPE_UNIVERSE = 0x0
RT_SCOPE_SITE = 0xc8
RT_SCOPE_LINK = 0xfd
RT_SCOPE_HOST = 0xfe
RT_SCOPE_NOWHERE = 0xff
RT_TABLE_UNSPEC = 0x0
RT_TABLE_COMPAT = 0xfc
RT_TABLE_DEFAULT = 0xfd
RT_TABLE_MAIN = 0xfe
RT_TABLE_LOCAL = 0xff
RT_TABLE_MAX = 0xffffffff
RTA_UNSPEC = 0x0
RTA_DST = 0x1
RTA_SRC = 0x2
RTA_IIF = 0x3
RTA_OIF = 0x4
RTA_GATEWAY = 0x5
RTA_PRIORITY = 0x6
RTA_PREFSRC = 0x7
RTA_METRICS = 0x8
RTA_MULTIPATH = 0x9
RTA_FLOW = 0xb
RTA_CACHEINFO = 0xc
RTA_TABLE = 0xf
RTA_MARK = 0x10
RTA_MFC_STATS = 0x11
RTA_VIA = 0x12
RTA_NEWDST = 0x13
RTA_PREF = 0x14
RTA_ENCAP_TYPE = 0x15
RTA_ENCAP = 0x16
RTA_EXPIRES = 0x17
RTA_PAD = 0x18
RTA_UID = 0x19
RTA_TTL_PROPAGATE = 0x1a
RTA_IP_PROTO = 0x1b
RTA_SPORT = 0x1c
RTA_DPORT = 0x1d
RTN_UNSPEC = 0x0
RTN_UNICAST = 0x1
RTN_LOCAL = 0x2
RTN_BROADCAST = 0x3
RTN_ANYCAST = 0x4
RTN_MULTICAST = 0x5
RTN_BLACKHOLE = 0x6
RTN_UNREACHABLE = 0x7
RTN_PROHIBIT = 0x8
RTN_THROW = 0x9
RTN_NAT = 0xa
RTN_XRESOLVE = 0xb
RTNLGRP_NONE = 0x0
RTNLGRP_LINK = 0x1
RTNLGRP_NOTIFY = 0x2
RTNLGRP_NEIGH = 0x3
RTNLGRP_TC = 0x4
RTNLGRP_IPV4_IFADDR = 0x5
RTNLGRP_IPV4_MROUTE = 0x6
RTNLGRP_IPV4_ROUTE = 0x7
RTNLGRP_IPV4_RULE = 0x8
RTNLGRP_IPV6_IFADDR = 0x9
RTNLGRP_IPV6_MROUTE = 0xa
RTNLGRP_IPV6_ROUTE = 0xb
RTNLGRP_IPV6_IFINFO = 0xc
RTNLGRP_IPV6_PREFIX = 0x12
RTNLGRP_IPV6_RULE = 0x13
RTNLGRP_ND_USEROPT = 0x14
SizeofNlMsghdr = 0x10
SizeofNlMsgerr = 0x14
SizeofRtGenmsg = 0x1
SizeofNlAttr = 0x4
SizeofRtAttr = 0x4
SizeofIfInfomsg = 0x10
SizeofIfAddrmsg = 0x8
SizeofRtMsg = 0xc
SizeofRtNexthop = 0x8
SizeofNdUseroptmsg = 0x10
SizeofNdMsg = 0xc
)
type NlMsghdr struct {
Len uint32
Type uint16
Flags uint16
Seq uint32
Pid uint32
}
type NlMsgerr struct {
Error int32
Msg NlMsghdr
}
type RtGenmsg struct {
Family uint8
}
type NlAttr struct {
Len uint16
Type uint16
}
type RtAttr struct {
Len uint16
Type uint16
}
type IfInfomsg struct {
Family uint8
_ uint8
Type uint16
Index int32
Flags uint32
Change uint32
}
type IfAddrmsg struct {
Family uint8
Prefixlen uint8
Flags uint8
Scope uint8
Index uint32
}
type RtMsg struct {
Family uint8
Dst_len uint8
Src_len uint8
Tos uint8
Table uint8
Protocol uint8
Scope uint8
Type uint8
Flags uint32
}
type RtNexthop struct {
Len uint16
Flags uint8
Hops uint8
Ifindex int32
}
type NdUseroptmsg struct {
Family uint8
Pad1 uint8
Opts_len uint16
Ifindex int32
Icmp_type uint8
Icmp_code uint8
Pad2 uint16
Pad3 uint32
}
type NdMsg struct {
Family uint8
Pad1 uint8
Pad2 uint16
Ifindex int32
State uint16
Flags uint8
Type uint8
}
const (
SizeofSockFilter = 0x8
SizeofSockFprog = 0x10
)
type SockFilter struct {
Code uint16
Jt uint8
Jf uint8
K uint32
}
type SockFprog struct {
Len uint16
Filter *SockFilter
}
type InotifyEvent struct {
Wd int32
Mask uint32
Cookie uint32
Len uint32
}
const SizeofInotifyEvent = 0x10
type PtraceRegs struct {
Pc uint64
Ra uint64
Sp uint64
Gp uint64
Tp uint64
T0 uint64
T1 uint64
T2 uint64
S0 uint64
S1 uint64
A0 uint64
A1 uint64
A2 uint64
A3 uint64
A4 uint64
A5 uint64
A6 uint64
A7 uint64
S2 uint64
S3 uint64
S4 uint64
S5 uint64
S6 uint64
S7 uint64
S8 uint64
S9 uint64
S10 uint64
S11 uint64
T3 uint64
T4 uint64
T5 uint64
T6 uint64
}
type FdSet struct {
Bits [16]int64
}
type Sysinfo_t struct {
Uptime int64
Loads [3]uint64
Totalram uint64
Freeram uint64
Sharedram uint64
Bufferram uint64
Totalswap uint64
Freeswap uint64
Procs uint16
Pad uint16
Totalhigh uint64
Freehigh uint64
Unit uint32
_ [0]uint8
_ [4]byte
}
type Utsname struct {
Sysname [65]byte
Nodename [65]byte
Release [65]byte
Version [65]byte
Machine [65]byte
Domainname [65]byte
}
type Ustat_t struct {
Tfree int32
Tinode uint64
Fname [6]uint8
Fpack [6]uint8
_ [4]byte
}
type EpollEvent struct {
Events uint32
Fd int32
Pad int32
}
const (
AT_EMPTY_PATH = 0x1000
AT_FDCWD = -0x64
AT_NO_AUTOMOUNT = 0x800
AT_REMOVEDIR = 0x200
AT_STATX_SYNC_AS_STAT = 0x0
AT_STATX_FORCE_SYNC = 0x2000
AT_STATX_DONT_SYNC = 0x4000
AT_SYMLINK_FOLLOW = 0x400
AT_SYMLINK_NOFOLLOW = 0x100
AT_EACCESS = 0x200
)
type PollFd struct {
Fd int32
Events int16
Revents int16
}
const (
POLLIN = 0x1
POLLPRI = 0x2
POLLOUT = 0x4
POLLRDHUP = 0x2000
POLLERR = 0x8
POLLHUP = 0x10
POLLNVAL = 0x20
)
type Sigset_t struct {
Val [16]uint64
}
type SignalfdSiginfo struct {
Signo uint32
Errno int32
Code int32
Pid uint32
Uid uint32
Fd int32
Tid uint32
Band uint32
Overrun uint32
Trapno uint32
Status int32
Int int32
Ptr uint64
Utime uint64
Stime uint64
Addr uint64
Addr_lsb uint16
_ uint16
Syscall int32
Call_addr uint64
Arch uint32
_ [28]uint8
}
const PERF_IOC_FLAG_GROUP = 0x1
type Termios struct {
Iflag uint32
Oflag uint32
Cflag uint32
Lflag uint32
Line uint8
Cc [19]uint8
Ispeed uint32
Ospeed uint32
}
type Winsize struct {
Row uint16
Col uint16
Xpixel uint16
Ypixel uint16
}
type Taskstats struct {
Version uint16
Ac_exitcode uint32
Ac_flag uint8
Ac_nice uint8
Cpu_count uint64
Cpu_delay_total uint64
Blkio_count uint64
Blkio_delay_total uint64
Swapin_count uint64
Swapin_delay_total uint64
Cpu_run_real_total uint64
Cpu_run_virtual_total uint64
Ac_comm [32]uint8
Ac_sched uint8
Ac_pad [3]uint8
_ [4]byte
Ac_uid uint32
Ac_gid uint32
Ac_pid uint32
Ac_ppid uint32
Ac_btime uint32
Ac_etime uint64
Ac_utime uint64
Ac_stime uint64
Ac_minflt uint64
Ac_majflt uint64
Coremem uint64
Virtmem uint64
Hiwater_rss uint64
Hiwater_vm uint64
Read_char uint64
Write_char uint64
Read_syscalls uint64
Write_syscalls uint64
Read_bytes uint64
Write_bytes uint64
Cancelled_write_bytes uint64
Nvcsw uint64
Nivcsw uint64
Ac_utimescaled uint64
Ac_stimescaled uint64
Cpu_scaled_run_real_total uint64
Freepages_count uint64
Freepages_delay_total uint64
Thrashing_count uint64
Thrashing_delay_total uint64
}
const (
TASKSTATS_CMD_UNSPEC = 0x0
TASKSTATS_CMD_GET = 0x1
TASKSTATS_CMD_NEW = 0x2
TASKSTATS_TYPE_UNSPEC = 0x0
TASKSTATS_TYPE_PID = 0x1
TASKSTATS_TYPE_TGID = 0x2
TASKSTATS_TYPE_STATS = 0x3
TASKSTATS_TYPE_AGGR_PID = 0x4
TASKSTATS_TYPE_AGGR_TGID = 0x5
TASKSTATS_TYPE_NULL = 0x6
TASKSTATS_CMD_ATTR_UNSPEC = 0x0
TASKSTATS_CMD_ATTR_PID = 0x1
TASKSTATS_CMD_ATTR_TGID = 0x2
TASKSTATS_CMD_ATTR_REGISTER_CPUMASK = 0x3
TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK = 0x4
)
type CGroupStats struct {
Sleeping uint64
Running uint64
Stopped uint64
Uninterruptible uint64
Io_wait uint64
}
const (
CGROUPSTATS_CMD_UNSPEC = 0x3
CGROUPSTATS_CMD_GET = 0x4
CGROUPSTATS_CMD_NEW = 0x5
CGROUPSTATS_TYPE_UNSPEC = 0x0
CGROUPSTATS_TYPE_CGROUP_STATS = 0x1
CGROUPSTATS_CMD_ATTR_UNSPEC = 0x0
CGROUPSTATS_CMD_ATTR_FD = 0x1
)
type Genlmsghdr struct {
Cmd uint8
Version uint8
Reserved uint16
}
const (
CTRL_CMD_UNSPEC = 0x0
CTRL_CMD_NEWFAMILY = 0x1
CTRL_CMD_DELFAMILY = 0x2
CTRL_CMD_GETFAMILY = 0x3
CTRL_CMD_NEWOPS = 0x4
CTRL_CMD_DELOPS = 0x5
CTRL_CMD_GETOPS = 0x6
CTRL_CMD_NEWMCAST_GRP = 0x7
CTRL_CMD_DELMCAST_GRP = 0x8
CTRL_CMD_GETMCAST_GRP = 0x9
CTRL_ATTR_UNSPEC = 0x0
CTRL_ATTR_FAMILY_ID = 0x1
CTRL_ATTR_FAMILY_NAME = 0x2
CTRL_ATTR_VERSION = 0x3
CTRL_ATTR_HDRSIZE = 0x4
CTRL_ATTR_MAXATTR = 0x5
CTRL_ATTR_OPS = 0x6
CTRL_ATTR_MCAST_GROUPS = 0x7
CTRL_ATTR_OP_UNSPEC = 0x0
CTRL_ATTR_OP_ID = 0x1
CTRL_ATTR_OP_FLAGS = 0x2
CTRL_ATTR_MCAST_GRP_UNSPEC = 0x0
CTRL_ATTR_MCAST_GRP_NAME = 0x1
CTRL_ATTR_MCAST_GRP_ID = 0x2
)
type cpuMask uint64
const (
_CPU_SETSIZE = 0x400
_NCPUBITS = 0x40
)
const (
BDADDR_BREDR = 0x0
BDADDR_LE_PUBLIC = 0x1
BDADDR_LE_RANDOM = 0x2
)
type PerfEventAttr struct {
Type uint32
Size uint32
Config uint64
Sample uint64
Sample_type uint64
Read_format uint64
Bits uint64
Wakeup uint32
Bp_type uint32
Ext1 uint64
Ext2 uint64
Branch_sample_type uint64
Sample_regs_user uint64
Sample_stack_user uint32
Clockid int32
Sample_regs_intr uint64
Aux_watermark uint32
Sample_max_stack uint16
_ uint16
}
type PerfEventMmapPage struct {
Version uint32
Compat_version uint32
Lock uint32
Index uint32
Offset int64
Time_enabled uint64
Time_running uint64
Capabilities uint64
Pmc_width uint16
Time_shift uint16
Time_mult uint32
Time_offset uint64
Time_zero uint64
Size uint32
_ [948]uint8
Data_head uint64
Data_tail uint64
Data_offset uint64
Data_size uint64
Aux_head uint64
Aux_tail uint64
Aux_offset uint64
Aux_size uint64
}
const (
PerfBitDisabled uint64 = CBitFieldMaskBit0
PerfBitInherit = CBitFieldMaskBit1
PerfBitPinned = CBitFieldMaskBit2
PerfBitExclusive = CBitFieldMaskBit3
PerfBitExcludeUser = CBitFieldMaskBit4
PerfBitExcludeKernel = CBitFieldMaskBit5
PerfBitExcludeHv = CBitFieldMaskBit6
PerfBitExcludeIdle = CBitFieldMaskBit7
PerfBitMmap = CBitFieldMaskBit8
PerfBitComm = CBitFieldMaskBit9
PerfBitFreq = CBitFieldMaskBit10
PerfBitInheritStat = CBitFieldMaskBit11
PerfBitEnableOnExec = CBitFieldMaskBit12
PerfBitTask = CBitFieldMaskBit13
PerfBitWatermark = CBitFieldMaskBit14
PerfBitPreciseIPBit1 = CBitFieldMaskBit15
PerfBitPreciseIPBit2 = CBitFieldMaskBit16
PerfBitMmapData = CBitFieldMaskBit17
PerfBitSampleIDAll = CBitFieldMaskBit18
PerfBitExcludeHost = CBitFieldMaskBit19
PerfBitExcludeGuest = CBitFieldMaskBit20
PerfBitExcludeCallchainKernel = CBitFieldMaskBit21
PerfBitExcludeCallchainUser = CBitFieldMaskBit22
PerfBitMmap2 = CBitFieldMaskBit23
PerfBitCommExec = CBitFieldMaskBit24
PerfBitUseClockID = CBitFieldMaskBit25
PerfBitContextSwitch = CBitFieldMaskBit26
)
const (
PERF_TYPE_HARDWARE = 0x0
PERF_TYPE_SOFTWARE = 0x1
PERF_TYPE_TRACEPOINT = 0x2
PERF_TYPE_HW_CACHE = 0x3
PERF_TYPE_RAW = 0x4
PERF_TYPE_BREAKPOINT = 0x5
PERF_COUNT_HW_CPU_CYCLES = 0x0
PERF_COUNT_HW_INSTRUCTIONS = 0x1
PERF_COUNT_HW_CACHE_REFERENCES = 0x2
PERF_COUNT_HW_CACHE_MISSES = 0x3
PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 0x4
PERF_COUNT_HW_BRANCH_MISSES = 0x5
PERF_COUNT_HW_BUS_CYCLES = 0x6
PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 0x8
PERF_COUNT_HW_REF_CPU_CYCLES = 0x9
PERF_COUNT_HW_CACHE_L1D = 0x0
PERF_COUNT_HW_CACHE_L1I = 0x1
PERF_COUNT_HW_CACHE_LL = 0x2
PERF_COUNT_HW_CACHE_DTLB = 0x3
PERF_COUNT_HW_CACHE_ITLB = 0x4
PERF_COUNT_HW_CACHE_BPU = 0x5
PERF_COUNT_HW_CACHE_NODE = 0x6
PERF_COUNT_HW_CACHE_OP_READ = 0x0
PERF_COUNT_HW_CACHE_OP_WRITE = 0x1
PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
PERF_COUNT_HW_CACHE_RESULT_MISS = 0x1
PERF_COUNT_SW_CPU_CLOCK = 0x0
PERF_COUNT_SW_TASK_CLOCK = 0x1
PERF_COUNT_SW_PAGE_FAULTS = 0x2
PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
PERF_COUNT_SW_CPU_MIGRATIONS = 0x4
PERF_COUNT_SW_PAGE_FAULTS_MIN = 0x5
PERF_COUNT_SW_PAGE_FAULTS_MAJ = 0x6
PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
PERF_COUNT_SW_EMULATION_FAULTS = 0x8
PERF_COUNT_SW_DUMMY = 0x9
PERF_COUNT_SW_BPF_OUTPUT = 0xa
PERF_SAMPLE_IP = 0x1
PERF_SAMPLE_TID = 0x2
PERF_SAMPLE_TIME = 0x4
PERF_SAMPLE_ADDR = 0x8
PERF_SAMPLE_READ = 0x10
PERF_SAMPLE_CALLCHAIN = 0x20
PERF_SAMPLE_ID = 0x40
PERF_SAMPLE_CPU = 0x80
PERF_SAMPLE_PERIOD = 0x100
PERF_SAMPLE_STREAM_ID = 0x200
PERF_SAMPLE_RAW = 0x400
PERF_SAMPLE_BRANCH_STACK = 0x800
PERF_SAMPLE_BRANCH_USER = 0x1
PERF_SAMPLE_BRANCH_KERNEL = 0x2
PERF_SAMPLE_BRANCH_HV = 0x4
PERF_SAMPLE_BRANCH_ANY = 0x8
PERF_SAMPLE_BRANCH_ANY_CALL = 0x10
PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
PERF_SAMPLE_BRANCH_IND_CALL = 0x40
PERF_SAMPLE_BRANCH_ABORT_TX = 0x80
PERF_SAMPLE_BRANCH_IN_TX = 0x100
PERF_SAMPLE_BRANCH_NO_TX = 0x200
PERF_SAMPLE_BRANCH_COND = 0x400
PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
PERF_SAMPLE_BRANCH_IND_JUMP = 0x1000
PERF_SAMPLE_BRANCH_CALL = 0x2000
PERF_SAMPLE_BRANCH_NO_FLAGS = 0x4000
PERF_SAMPLE_BRANCH_NO_CYCLES = 0x8000
PERF_SAMPLE_BRANCH_TYPE_SAVE = 0x10000
PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
PERF_FORMAT_ID = 0x4
PERF_FORMAT_GROUP = 0x8
PERF_RECORD_MMAP = 0x1
PERF_RECORD_LOST = 0x2
PERF_RECORD_COMM = 0x3
PERF_RECORD_EXIT = 0x4
PERF_RECORD_THROTTLE = 0x5
PERF_RECORD_UNTHROTTLE = 0x6
PERF_RECORD_FORK = 0x7
PERF_RECORD_READ = 0x8
PERF_RECORD_SAMPLE = 0x9
PERF_RECORD_MMAP2 = 0xa
PERF_RECORD_AUX = 0xb
PERF_RECORD_ITRACE_START = 0xc
PERF_RECORD_LOST_SAMPLES = 0xd
PERF_RECORD_SWITCH = 0xe
PERF_RECORD_SWITCH_CPU_WIDE = 0xf
PERF_RECORD_NAMESPACES = 0x10
PERF_CONTEXT_HV = -0x20
PERF_CONTEXT_KERNEL = -0x80
PERF_CONTEXT_USER = -0x200
PERF_CONTEXT_GUEST = -0x800
PERF_CONTEXT_GUEST_KERNEL = -0x880
PERF_CONTEXT_GUEST_USER = -0xa00
PERF_FLAG_FD_NO_GROUP = 0x1
PERF_FLAG_FD_OUTPUT = 0x2
PERF_FLAG_PID_CGROUP = 0x4
PERF_FLAG_FD_CLOEXEC = 0x8
)
const (
CBitFieldMaskBit0 = 0x1
CBitFieldMaskBit1 = 0x2
CBitFieldMaskBit2 = 0x4
CBitFieldMaskBit3 = 0x8
CBitFieldMaskBit4 = 0x10
CBitFieldMaskBit5 = 0x20
CBitFieldMaskBit6 = 0x40
CBitFieldMaskBit7 = 0x80
CBitFieldMaskBit8 = 0x100
CBitFieldMaskBit9 = 0x200
CBitFieldMaskBit10 = 0x400
CBitFieldMaskBit11 = 0x800
CBitFieldMaskBit12 = 0x1000
CBitFieldMaskBit13 = 0x2000
CBitFieldMaskBit14 = 0x4000
CBitFieldMaskBit15 = 0x8000
CBitFieldMaskBit16 = 0x10000
CBitFieldMaskBit17 = 0x20000
CBitFieldMaskBit18 = 0x40000
CBitFieldMaskBit19 = 0x80000
CBitFieldMaskBit20 = 0x100000
CBitFieldMaskBit21 = 0x200000
CBitFieldMaskBit22 = 0x400000
CBitFieldMaskBit23 = 0x800000
CBitFieldMaskBit24 = 0x1000000
CBitFieldMaskBit25 = 0x2000000
CBitFieldMaskBit26 = 0x4000000
CBitFieldMaskBit27 = 0x8000000
CBitFieldMaskBit28 = 0x10000000
CBitFieldMaskBit29 = 0x20000000
CBitFieldMaskBit30 = 0x40000000
CBitFieldMaskBit31 = 0x80000000
CBitFieldMaskBit32 = 0x100000000
CBitFieldMaskBit33 = 0x200000000
CBitFieldMaskBit34 = 0x400000000
CBitFieldMaskBit35 = 0x800000000
CBitFieldMaskBit36 = 0x1000000000
CBitFieldMaskBit37 = 0x2000000000
CBitFieldMaskBit38 = 0x4000000000
CBitFieldMaskBit39 = 0x8000000000
CBitFieldMaskBit40 = 0x10000000000
CBitFieldMaskBit41 = 0x20000000000
CBitFieldMaskBit42 = 0x40000000000
CBitFieldMaskBit43 = 0x80000000000
CBitFieldMaskBit44 = 0x100000000000
CBitFieldMaskBit45 = 0x200000000000
CBitFieldMaskBit46 = 0x400000000000
CBitFieldMaskBit47 = 0x800000000000
CBitFieldMaskBit48 = 0x1000000000000
CBitFieldMaskBit49 = 0x2000000000000
CBitFieldMaskBit50 = 0x4000000000000
CBitFieldMaskBit51 = 0x8000000000000
CBitFieldMaskBit52 = 0x10000000000000
CBitFieldMaskBit53 = 0x20000000000000
CBitFieldMaskBit54 = 0x40000000000000
CBitFieldMaskBit55 = 0x80000000000000
CBitFieldMaskBit56 = 0x100000000000000
CBitFieldMaskBit57 = 0x200000000000000
CBitFieldMaskBit58 = 0x400000000000000
CBitFieldMaskBit59 = 0x800000000000000
CBitFieldMaskBit60 = 0x1000000000000000
CBitFieldMaskBit61 = 0x2000000000000000
CBitFieldMaskBit62 = 0x4000000000000000
CBitFieldMaskBit63 = 0x8000000000000000
)
type SockaddrStorage struct {
Family uint16
_ [118]uint8
_ uint64
}
type TCPMD5Sig struct {
Addr SockaddrStorage
Flags uint8
Prefixlen uint8
Keylen uint16
_ uint32
Key [80]uint8
}
type HDDriveCmdHdr struct {
Command uint8
Number uint8
Feature uint8
Count uint8
}
type HDGeometry struct {
Heads uint8
Sectors uint8
Cylinders uint16
Start uint64
}
type HDDriveID struct {
Config uint16
Cyls uint16
Reserved2 uint16
Heads uint16
Track_bytes uint16
Sector_bytes uint16
Sectors uint16
Vendor0 uint16
Vendor1 uint16
Vendor2 uint16
Serial_no [20]uint8
Buf_type uint16
Buf_size uint16
Ecc_bytes uint16
Fw_rev [8]uint8
Model [40]uint8
Max_multsect uint8
Vendor3 uint8
Dword_io uint16
Vendor4 uint8
Capability uint8
Reserved50 uint16
Vendor5 uint8
TPIO uint8
Vendor6 uint8
TDMA uint8
Field_valid uint16
Cur_cyls uint16
Cur_heads uint16
Cur_sectors uint16
Cur_capacity0 uint16
Cur_capacity1 uint16
Multsect uint8
Multsect_valid uint8
Lba_capacity uint32
Dma_1word uint16
Dma_mword uint16
Eide_pio_modes uint16
Eide_dma_min uint16
Eide_dma_time uint16
Eide_pio uint16
Eide_pio_iordy uint16
Words69_70 [2]uint16
Words71_74 [4]uint16
Queue_depth uint16
Words76_79 [4]uint16
Major_rev_num uint16
Minor_rev_num uint16
Command_set_1 uint16
Command_set_2 uint16
Cfsse uint16
Cfs_enable_1 uint16
Cfs_enable_2 uint16
Csf_default uint16
Dma_ultra uint16
Trseuc uint16
TrsEuc uint16
CurAPMvalues uint16
Mprc uint16
Hw_config uint16
Acoustic uint16
Msrqs uint16
Sxfert uint16
Sal uint16
Spg uint32
Lba_capacity_2 uint64
Words104_125 [22]uint16
Last_lun uint16
Word127 uint16
Dlf uint16
Csfo uint16
Words130_155 [26]uint16
Word156 uint16
Words157_159 [3]uint16
Cfa_power uint16
Words161_175 [15]uint16
Words176_205 [30]uint16
Words206_254 [49]uint16
Integrity_word uint16
}
type Statfs_t struct {
Type int64
Bsize int64
Blocks uint64
Bfree uint64
Bavail uint64
Files uint64
Ffree uint64
Fsid Fsid
Namelen int64
Frsize int64
Flags int64
Spare [4]int64
}
const (
ST_MANDLOCK = 0x40
ST_NOATIME = 0x400
ST_NODEV = 0x4
ST_NODIRATIME = 0x800
ST_NOEXEC = 0x8
ST_NOSUID = 0x2
ST_RDONLY = 0x1
ST_RELATIME = 0x1000
ST_SYNCHRONOUS = 0x10
)
type TpacketHdr struct {
Status uint64
Len uint32
Snaplen uint32
Mac uint16
Net uint16
Sec uint32
Usec uint32
_ [4]byte
}
type Tpacket2Hdr struct {
Status uint32
Len uint32
Snaplen uint32
Mac uint16
Net uint16
Sec uint32
Nsec uint32
Vlan_tci uint16
Vlan_tpid uint16
_ [4]uint8
}
type Tpacket3Hdr struct {
Next_offset uint32
Sec uint32
Nsec uint32
Snaplen uint32
Len uint32
Status uint32
Mac uint16
Net uint16
Hv1 TpacketHdrVariant1
_ [8]uint8
}
type TpacketHdrVariant1 struct {
Rxhash uint32
Vlan_tci uint32
Vlan_tpid uint16
_ uint16
}
type TpacketBlockDesc struct {
Version uint32
To_priv uint32
Hdr [40]byte
}
type TpacketBDTS struct {
Sec uint32
Usec uint32
}
type TpacketHdrV1 struct {
Block_status uint32
Num_pkts uint32
Offset_to_first_pkt uint32
Blk_len uint32
Seq_num uint64
Ts_first_pkt TpacketBDTS
Ts_last_pkt TpacketBDTS
}
type TpacketReq struct {
Block_size uint32
Block_nr uint32
Frame_size uint32
Frame_nr uint32
}
type TpacketReq3 struct {
Block_size uint32
Block_nr uint32
Frame_size uint32
Frame_nr uint32
Retire_blk_tov uint32
Sizeof_priv uint32
Feature_req_word uint32
}
type TpacketStats struct {
Packets uint32
Drops uint32
}
type TpacketStatsV3 struct {
Packets uint32
Drops uint32
Freeze_q_cnt uint32
}
type TpacketAuxdata struct {
Status uint32
Len uint32
Snaplen uint32
Mac uint16
Net uint16
Vlan_tci uint16
Vlan_tpid uint16
}
const (
TPACKET_V1 = 0x0
TPACKET_V2 = 0x1
TPACKET_V3 = 0x2
)
const (
SizeofTpacketHdr = 0x20
SizeofTpacket2Hdr = 0x20
SizeofTpacket3Hdr = 0x30
SizeofTpacketStats = 0x8
SizeofTpacketStatsV3 = 0xc
)
const (
NF_INET_PRE_ROUTING = 0x0
NF_INET_LOCAL_IN = 0x1
NF_INET_FORWARD = 0x2
NF_INET_LOCAL_OUT = 0x3
NF_INET_POST_ROUTING = 0x4
NF_INET_NUMHOOKS = 0x5
)
const (
NF_NETDEV_INGRESS = 0x0
NF_NETDEV_NUMHOOKS = 0x1
)
const (
NFPROTO_UNSPEC = 0x0
NFPROTO_INET = 0x1
NFPROTO_IPV4 = 0x2
NFPROTO_ARP = 0x3
NFPROTO_NETDEV = 0x5
NFPROTO_BRIDGE = 0x7
NFPROTO_IPV6 = 0xa
NFPROTO_DECNET = 0xc
NFPROTO_NUMPROTO = 0xd
)
type Nfgenmsg struct {
Nfgen_family uint8
Version uint8
Res_id uint16
}
const (
NFNL_BATCH_UNSPEC = 0x0
NFNL_BATCH_GENID = 0x1
)
const (
NFT_REG_VERDICT = 0x0
NFT_REG_1 = 0x1
NFT_REG_2 = 0x2
NFT_REG_3 = 0x3
NFT_REG_4 = 0x4
NFT_REG32_00 = 0x8
NFT_REG32_01 = 0x9
NFT_REG32_02 = 0xa
NFT_REG32_03 = 0xb
NFT_REG32_04 = 0xc
NFT_REG32_05 = 0xd
NFT_REG32_06 = 0xe
NFT_REG32_07 = 0xf
NFT_REG32_08 = 0x10
NFT_REG32_09 = 0x11
NFT_REG32_10 = 0x12
NFT_REG32_11 = 0x13
NFT_REG32_12 = 0x14
NFT_REG32_13 = 0x15
NFT_REG32_14 = 0x16
NFT_REG32_15 = 0x17
NFT_CONTINUE = -0x1
NFT_BREAK = -0x2
NFT_JUMP = -0x3
NFT_GOTO = -0x4
NFT_RETURN = -0x5
NFT_MSG_NEWTABLE = 0x0
NFT_MSG_GETTABLE = 0x1
NFT_MSG_DELTABLE = 0x2
NFT_MSG_NEWCHAIN = 0x3
NFT_MSG_GETCHAIN = 0x4
NFT_MSG_DELCHAIN = 0x5
NFT_MSG_NEWRULE = 0x6
NFT_MSG_GETRULE = 0x7
NFT_MSG_DELRULE = 0x8
NFT_MSG_NEWSET = 0x9
NFT_MSG_GETSET = 0xa
NFT_MSG_DELSET = 0xb
NFT_MSG_NEWSETELEM = 0xc
NFT_MSG_GETSETELEM = 0xd
NFT_MSG_DELSETELEM = 0xe
NFT_MSG_NEWGEN = 0xf
NFT_MSG_GETGEN = 0x10
NFT_MSG_TRACE = 0x11
NFT_MSG_NEWOBJ = 0x12
NFT_MSG_GETOBJ = 0x13
NFT_MSG_DELOBJ = 0x14
NFT_MSG_GETOBJ_RESET = 0x15
NFT_MSG_MAX = 0x19
NFTA_LIST_UNPEC = 0x0
NFTA_LIST_ELEM = 0x1
NFTA_HOOK_UNSPEC = 0x0
NFTA_HOOK_HOOKNUM = 0x1
NFTA_HOOK_PRIORITY = 0x2
NFTA_HOOK_DEV = 0x3
NFT_TABLE_F_DORMANT = 0x1
NFTA_TABLE_UNSPEC = 0x0
NFTA_TABLE_NAME = 0x1
NFTA_TABLE_FLAGS = 0x2
NFTA_TABLE_USE = 0x3
NFTA_CHAIN_UNSPEC = 0x0
NFTA_CHAIN_TABLE = 0x1
NFTA_CHAIN_HANDLE = 0x2
NFTA_CHAIN_NAME = 0x3
NFTA_CHAIN_HOOK = 0x4
NFTA_CHAIN_POLICY = 0x5
NFTA_CHAIN_USE = 0x6
NFTA_CHAIN_TYPE = 0x7
NFTA_CHAIN_COUNTERS = 0x8
NFTA_CHAIN_PAD = 0x9
NFTA_RULE_UNSPEC = 0x0
NFTA_RULE_TABLE = 0x1
NFTA_RULE_CHAIN = 0x2
NFTA_RULE_HANDLE = 0x3
NFTA_RULE_EXPRESSIONS = 0x4
NFTA_RULE_COMPAT = 0x5
NFTA_RULE_POSITION = 0x6
NFTA_RULE_USERDATA = 0x7
NFTA_RULE_PAD = 0x8
NFTA_RULE_ID = 0x9
NFT_RULE_COMPAT_F_INV = 0x2
NFT_RULE_COMPAT_F_MASK = 0x2
NFTA_RULE_COMPAT_UNSPEC = 0x0
NFTA_RULE_COMPAT_PROTO = 0x1
NFTA_RULE_COMPAT_FLAGS = 0x2
NFT_SET_ANONYMOUS = 0x1
NFT_SET_CONSTANT = 0x2
NFT_SET_INTERVAL = 0x4
NFT_SET_MAP = 0x8
NFT_SET_TIMEOUT = 0x10
NFT_SET_EVAL = 0x20
NFT_SET_OBJECT = 0x40
NFT_SET_POL_PERFORMANCE = 0x0
NFT_SET_POL_MEMORY = 0x1
NFTA_SET_DESC_UNSPEC = 0x0
NFTA_SET_DESC_SIZE = 0x1
NFTA_SET_UNSPEC = 0x0
NFTA_SET_TABLE = 0x1
NFTA_SET_NAME = 0x2
NFTA_SET_FLAGS = 0x3
NFTA_SET_KEY_TYPE = 0x4
NFTA_SET_KEY_LEN = 0x5
NFTA_SET_DATA_TYPE = 0x6
NFTA_SET_DATA_LEN = 0x7
NFTA_SET_POLICY = 0x8
NFTA_SET_DESC = 0x9
NFTA_SET_ID = 0xa
NFTA_SET_TIMEOUT = 0xb
NFTA_SET_GC_INTERVAL = 0xc
NFTA_SET_USERDATA = 0xd
NFTA_SET_PAD = 0xe
NFTA_SET_OBJ_TYPE = 0xf
NFT_SET_ELEM_INTERVAL_END = 0x1
NFTA_SET_ELEM_UNSPEC = 0x0
NFTA_SET_ELEM_KEY = 0x1
NFTA_SET_ELEM_DATA = 0x2
NFTA_SET_ELEM_FLAGS = 0x3
NFTA_SET_ELEM_TIMEOUT = 0x4
NFTA_SET_ELEM_EXPIRATION = 0x5
NFTA_SET_ELEM_USERDATA = 0x6
NFTA_SET_ELEM_EXPR = 0x7
NFTA_SET_ELEM_PAD = 0x8
NFTA_SET_ELEM_OBJREF = 0x9
NFTA_SET_ELEM_LIST_UNSPEC = 0x0
NFTA_SET_ELEM_LIST_TABLE = 0x1
NFTA_SET_ELEM_LIST_SET = 0x2
NFTA_SET_ELEM_LIST_ELEMENTS = 0x3
NFTA_SET_ELEM_LIST_SET_ID = 0x4
NFT_DATA_VALUE = 0x0
NFT_DATA_VERDICT = 0xffffff00
NFTA_DATA_UNSPEC = 0x0
NFTA_DATA_VALUE = 0x1
NFTA_DATA_VERDICT = 0x2
NFTA_VERDICT_UNSPEC = 0x0
NFTA_VERDICT_CODE = 0x1
NFTA_VERDICT_CHAIN = 0x2
NFTA_EXPR_UNSPEC = 0x0
NFTA_EXPR_NAME = 0x1
NFTA_EXPR_DATA = 0x2
NFTA_IMMEDIATE_UNSPEC = 0x0
NFTA_IMMEDIATE_DREG = 0x1
NFTA_IMMEDIATE_DATA = 0x2
NFTA_BITWISE_UNSPEC = 0x0
NFTA_BITWISE_SREG = 0x1
NFTA_BITWISE_DREG = 0x2
NFTA_BITWISE_LEN = 0x3
NFTA_BITWISE_MASK = 0x4
NFTA_BITWISE_XOR = 0x5
NFT_BYTEORDER_NTOH = 0x0
NFT_BYTEORDER_HTON = 0x1
NFTA_BYTEORDER_UNSPEC = 0x0
NFTA_BYTEORDER_SREG = 0x1
NFTA_BYTEORDER_DREG = 0x2
NFTA_BYTEORDER_OP = 0x3
NFTA_BYTEORDER_LEN = 0x4
NFTA_BYTEORDER_SIZE = 0x5
NFT_CMP_EQ = 0x0
NFT_CMP_NEQ = 0x1
NFT_CMP_LT = 0x2
NFT_CMP_LTE = 0x3
NFT_CMP_GT = 0x4
NFT_CMP_GTE = 0x5
NFTA_CMP_UNSPEC = 0x0
NFTA_CMP_SREG = 0x1
NFTA_CMP_OP = 0x2
NFTA_CMP_DATA = 0x3
NFT_RANGE_EQ = 0x0
NFT_RANGE_NEQ = 0x1
NFTA_RANGE_UNSPEC = 0x0
NFTA_RANGE_SREG = 0x1
NFTA_RANGE_OP = 0x2
NFTA_RANGE_FROM_DATA = 0x3
NFTA_RANGE_TO_DATA = 0x4
NFT_LOOKUP_F_INV = 0x1
NFTA_LOOKUP_UNSPEC = 0x0
NFTA_LOOKUP_SET = 0x1
NFTA_LOOKUP_SREG = 0x2
NFTA_LOOKUP_DREG = 0x3
NFTA_LOOKUP_SET_ID = 0x4
NFTA_LOOKUP_FLAGS = 0x5
NFT_DYNSET_OP_ADD = 0x0
NFT_DYNSET_OP_UPDATE = 0x1
NFT_DYNSET_F_INV = 0x1
NFTA_DYNSET_UNSPEC = 0x0
NFTA_DYNSET_SET_NAME = 0x1
NFTA_DYNSET_SET_ID = 0x2
NFTA_DYNSET_OP = 0x3
NFTA_DYNSET_SREG_KEY = 0x4
NFTA_DYNSET_SREG_DATA = 0x5
NFTA_DYNSET_TIMEOUT = 0x6
NFTA_DYNSET_EXPR = 0x7
NFTA_DYNSET_PAD = 0x8
NFTA_DYNSET_FLAGS = 0x9
NFT_PAYLOAD_LL_HEADER = 0x0
NFT_PAYLOAD_NETWORK_HEADER = 0x1
NFT_PAYLOAD_TRANSPORT_HEADER = 0x2
NFT_PAYLOAD_CSUM_NONE = 0x0
NFT_PAYLOAD_CSUM_INET = 0x1
NFT_PAYLOAD_L4CSUM_PSEUDOHDR = 0x1
NFTA_PAYLOAD_UNSPEC = 0x0
NFTA_PAYLOAD_DREG = 0x1
NFTA_PAYLOAD_BASE = 0x2
NFTA_PAYLOAD_OFFSET = 0x3
NFTA_PAYLOAD_LEN = 0x4
NFTA_PAYLOAD_SREG = 0x5
NFTA_PAYLOAD_CSUM_TYPE = 0x6
NFTA_PAYLOAD_CSUM_OFFSET = 0x7
NFTA_PAYLOAD_CSUM_FLAGS = 0x8
NFT_EXTHDR_F_PRESENT = 0x1
NFT_EXTHDR_OP_IPV6 = 0x0
NFT_EXTHDR_OP_TCPOPT = 0x1
NFTA_EXTHDR_UNSPEC = 0x0
NFTA_EXTHDR_DREG = 0x1
NFTA_EXTHDR_TYPE = 0x2
NFTA_EXTHDR_OFFSET = 0x3
NFTA_EXTHDR_LEN = 0x4
NFTA_EXTHDR_FLAGS = 0x5
NFTA_EXTHDR_OP = 0x6
NFTA_EXTHDR_SREG = 0x7
NFT_META_LEN = 0x0
NFT_META_PROTOCOL = 0x1
NFT_META_PRIORITY = 0x2
NFT_META_MARK = 0x3
NFT_META_IIF = 0x4
NFT_META_OIF = 0x5
NFT_META_IIFNAME = 0x6
NFT_META_OIFNAME = 0x7
NFT_META_IIFTYPE = 0x8
NFT_META_OIFTYPE = 0x9
NFT_META_SKUID = 0xa
NFT_META_SKGID = 0xb
NFT_META_NFTRACE = 0xc
NFT_META_RTCLASSID = 0xd
NFT_META_SECMARK = 0xe
NFT_META_NFPROTO = 0xf
NFT_META_L4PROTO = 0x10
NFT_META_BRI_IIFNAME = 0x11
NFT_META_BRI_OIFNAME = 0x12
NFT_META_PKTTYPE = 0x13
NFT_META_CPU = 0x14
NFT_META_IIFGROUP = 0x15
NFT_META_OIFGROUP = 0x16
NFT_META_CGROUP = 0x17
NFT_META_PRANDOM = 0x18
NFT_RT_CLASSID = 0x0
NFT_RT_NEXTHOP4 = 0x1
NFT_RT_NEXTHOP6 = 0x2
NFT_RT_TCPMSS = 0x3
NFT_HASH_JENKINS = 0x0
NFT_HASH_SYM = 0x1
NFTA_HASH_UNSPEC = 0x0
NFTA_HASH_SREG = 0x1
NFTA_HASH_DREG = 0x2
NFTA_HASH_LEN = 0x3
NFTA_HASH_MODULUS = 0x4
NFTA_HASH_SEED = 0x5
NFTA_HASH_OFFSET = 0x6
NFTA_HASH_TYPE = 0x7
NFTA_META_UNSPEC = 0x0
NFTA_META_DREG = 0x1
NFTA_META_KEY = 0x2
NFTA_META_SREG = 0x3
NFTA_RT_UNSPEC = 0x0
NFTA_RT_DREG = 0x1
NFTA_RT_KEY = 0x2
NFT_CT_STATE = 0x0
NFT_CT_DIRECTION = 0x1
NFT_CT_STATUS = 0x2
NFT_CT_MARK = 0x3
NFT_CT_SECMARK = 0x4
NFT_CT_EXPIRATION = 0x5
NFT_CT_HELPER = 0x6
NFT_CT_L3PROTOCOL = 0x7
NFT_CT_SRC = 0x8
NFT_CT_DST = 0x9
NFT_CT_PROTOCOL = 0xa
NFT_CT_PROTO_SRC = 0xb
NFT_CT_PROTO_DST = 0xc
NFT_CT_LABELS = 0xd
NFT_CT_PKTS = 0xe
NFT_CT_BYTES = 0xf
NFT_CT_AVGPKT = 0x10
NFT_CT_ZONE = 0x11
NFT_CT_EVENTMASK = 0x12
NFTA_CT_UNSPEC = 0x0
NFTA_CT_DREG = 0x1
NFTA_CT_KEY = 0x2
NFTA_CT_DIRECTION = 0x3
NFTA_CT_SREG = 0x4
NFT_LIMIT_PKTS = 0x0
NFT_LIMIT_PKT_BYTES = 0x1
NFT_LIMIT_F_INV = 0x1
NFTA_LIMIT_UNSPEC = 0x0
NFTA_LIMIT_RATE = 0x1
NFTA_LIMIT_UNIT = 0x2
NFTA_LIMIT_BURST = 0x3
NFTA_LIMIT_TYPE = 0x4
NFTA_LIMIT_FLAGS = 0x5
NFTA_LIMIT_PAD = 0x6
NFTA_COUNTER_UNSPEC = 0x0
NFTA_COUNTER_BYTES = 0x1
NFTA_COUNTER_PACKETS = 0x2
NFTA_COUNTER_PAD = 0x3
NFTA_LOG_UNSPEC = 0x0
NFTA_LOG_GROUP = 0x1
NFTA_LOG_PREFIX = 0x2
NFTA_LOG_SNAPLEN = 0x3
NFTA_LOG_QTHRESHOLD = 0x4
NFTA_LOG_LEVEL = 0x5
NFTA_LOG_FLAGS = 0x6
NFTA_QUEUE_UNSPEC = 0x0
NFTA_QUEUE_NUM = 0x1
NFTA_QUEUE_TOTAL = 0x2
NFTA_QUEUE_FLAGS = 0x3
NFTA_QUEUE_SREG_QNUM = 0x4
NFT_QUOTA_F_INV = 0x1
NFT_QUOTA_F_DEPLETED = 0x2
NFTA_QUOTA_UNSPEC = 0x0
NFTA_QUOTA_BYTES = 0x1
NFTA_QUOTA_FLAGS = 0x2
NFTA_QUOTA_PAD = 0x3
NFTA_QUOTA_CONSUMED = 0x4
NFT_REJECT_ICMP_UNREACH = 0x0
NFT_REJECT_TCP_RST = 0x1
NFT_REJECT_ICMPX_UNREACH = 0x2
NFT_REJECT_ICMPX_NO_ROUTE = 0x0
NFT_REJECT_ICMPX_PORT_UNREACH = 0x1
NFT_REJECT_ICMPX_HOST_UNREACH = 0x2
NFT_REJECT_ICMPX_ADMIN_PROHIBITED = 0x3
NFTA_REJECT_UNSPEC = 0x0
NFTA_REJECT_TYPE = 0x1
NFTA_REJECT_ICMP_CODE = 0x2
NFT_NAT_SNAT = 0x0
NFT_NAT_DNAT = 0x1
NFTA_NAT_UNSPEC = 0x0
NFTA_NAT_TYPE = 0x1
NFTA_NAT_FAMILY = 0x2
NFTA_NAT_REG_ADDR_MIN = 0x3
NFTA_NAT_REG_ADDR_MAX = 0x4
NFTA_NAT_REG_PROTO_MIN = 0x5
NFTA_NAT_REG_PROTO_MAX = 0x6
NFTA_NAT_FLAGS = 0x7
NFTA_MASQ_UNSPEC = 0x0
NFTA_MASQ_FLAGS = 0x1
NFTA_MASQ_REG_PROTO_MIN = 0x2
NFTA_MASQ_REG_PROTO_MAX = 0x3
NFTA_REDIR_UNSPEC = 0x0
NFTA_REDIR_REG_PROTO_MIN = 0x1
NFTA_REDIR_REG_PROTO_MAX = 0x2
NFTA_REDIR_FLAGS = 0x3
NFTA_DUP_UNSPEC = 0x0
NFTA_DUP_SREG_ADDR = 0x1
NFTA_DUP_SREG_DEV = 0x2
NFTA_FWD_UNSPEC = 0x0
NFTA_FWD_SREG_DEV = 0x1
NFTA_OBJREF_UNSPEC = 0x0
NFTA_OBJREF_IMM_TYPE = 0x1
NFTA_OBJREF_IMM_NAME = 0x2
NFTA_OBJREF_SET_SREG = 0x3
NFTA_OBJREF_SET_NAME = 0x4
NFTA_OBJREF_SET_ID = 0x5
NFTA_GEN_UNSPEC = 0x0
NFTA_GEN_ID = 0x1
NFTA_GEN_PROC_PID = 0x2
NFTA_GEN_PROC_NAME = 0x3
NFTA_FIB_UNSPEC = 0x0
NFTA_FIB_DREG = 0x1
NFTA_FIB_RESULT = 0x2
NFTA_FIB_FLAGS = 0x3
NFT_FIB_RESULT_UNSPEC = 0x0
NFT_FIB_RESULT_OIF = 0x1
NFT_FIB_RESULT_OIFNAME = 0x2
NFT_FIB_RESULT_ADDRTYPE = 0x3
NFTA_FIB_F_SADDR = 0x1
NFTA_FIB_F_DADDR = 0x2
NFTA_FIB_F_MARK = 0x4
NFTA_FIB_F_IIF = 0x8
NFTA_FIB_F_OIF = 0x10
NFTA_FIB_F_PRESENT = 0x20
NFTA_CT_HELPER_UNSPEC = 0x0
NFTA_CT_HELPER_NAME = 0x1
NFTA_CT_HELPER_L3PROTO = 0x2
NFTA_CT_HELPER_L4PROTO = 0x3
NFTA_OBJ_UNSPEC = 0x0
NFTA_OBJ_TABLE = 0x1
NFTA_OBJ_NAME = 0x2
NFTA_OBJ_TYPE = 0x3
NFTA_OBJ_DATA = 0x4
NFTA_OBJ_USE = 0x5
NFTA_TRACE_UNSPEC = 0x0
NFTA_TRACE_TABLE = 0x1
NFTA_TRACE_CHAIN = 0x2
NFTA_TRACE_RULE_HANDLE = 0x3
NFTA_TRACE_TYPE = 0x4
NFTA_TRACE_VERDICT = 0x5
NFTA_TRACE_ID = 0x6
NFTA_TRACE_LL_HEADER = 0x7
NFTA_TRACE_NETWORK_HEADER = 0x8
NFTA_TRACE_TRANSPORT_HEADER = 0x9
NFTA_TRACE_IIF = 0xa
NFTA_TRACE_IIFTYPE = 0xb
NFTA_TRACE_OIF = 0xc
NFTA_TRACE_OIFTYPE = 0xd
NFTA_TRACE_MARK = 0xe
NFTA_TRACE_NFPROTO = 0xf
NFTA_TRACE_POLICY = 0x10
NFTA_TRACE_PAD = 0x11
NFT_TRACETYPE_UNSPEC = 0x0
NFT_TRACETYPE_POLICY = 0x1
NFT_TRACETYPE_RETURN = 0x2
NFT_TRACETYPE_RULE = 0x3
NFTA_NG_UNSPEC = 0x0
NFTA_NG_DREG = 0x1
NFTA_NG_MODULUS = 0x2
NFTA_NG_TYPE = 0x3
NFTA_NG_OFFSET = 0x4
NFT_NG_INCREMENTAL = 0x0
NFT_NG_RANDOM = 0x1
)
type RTCTime struct {
Sec int32
Min int32
Hour int32
Mday int32
Mon int32
Year int32
Wday int32
Yday int32
Isdst int32
}
type RTCWkAlrm struct {
Enabled uint8
Pending uint8
Time RTCTime
}
type RTCPLLInfo struct {
Ctrl int32
Value int32
Max int32
Min int32
Posmult int32
Negmult int32
Clock int64
}
type BlkpgIoctlArg struct {
Op int32
Flags int32
Datalen int32
Data *byte
}
type BlkpgPartition struct {
Start int64
Length int64
Pno int32
Devname [64]uint8
Volname [64]uint8
_ [4]byte
}
const (
BLKPG = 0x1269
BLKPG_ADD_PARTITION = 0x1
BLKPG_DEL_PARTITION = 0x2
BLKPG_RESIZE_PARTITION = 0x3
)
const (
NETNSA_NONE = 0x0
NETNSA_NSID = 0x1
NETNSA_PID = 0x2
NETNSA_FD = 0x3
)
type XDPRingOffset struct {
Producer uint64
Consumer uint64
Desc uint64
}
type XDPMmapOffsets struct {
Rx XDPRingOffset
Tx XDPRingOffset
Fr XDPRingOffset
Cr XDPRingOffset
}
type XDPUmemReg struct {
Addr uint64
Len uint64
Size uint32
Headroom uint32
}
type XDPStatistics struct {
Rx_dropped uint64
Rx_invalid_descs uint64
Tx_invalid_descs uint64
}
type XDPDesc struct {
Addr uint64
Len uint32
Options uint32
}
const (
NCSI_CMD_UNSPEC = 0x0
NCSI_CMD_PKG_INFO = 0x1
NCSI_CMD_SET_INTERFACE = 0x2
NCSI_CMD_CLEAR_INTERFACE = 0x3
NCSI_ATTR_UNSPEC = 0x0
NCSI_ATTR_IFINDEX = 0x1
NCSI_ATTR_PACKAGE_LIST = 0x2
NCSI_ATTR_PACKAGE_ID = 0x3
NCSI_ATTR_CHANNEL_ID = 0x4
NCSI_PKG_ATTR_UNSPEC = 0x0
NCSI_PKG_ATTR = 0x1
NCSI_PKG_ATTR_ID = 0x2
NCSI_PKG_ATTR_FORCED = 0x3
NCSI_PKG_ATTR_CHANNEL_LIST = 0x4
NCSI_CHANNEL_ATTR_UNSPEC = 0x0
NCSI_CHANNEL_ATTR = 0x1
NCSI_CHANNEL_ATTR_ID = 0x2
NCSI_CHANNEL_ATTR_VERSION_MAJOR = 0x3
NCSI_CHANNEL_ATTR_VERSION_MINOR = 0x4
NCSI_CHANNEL_ATTR_VERSION_STR = 0x5
NCSI_CHANNEL_ATTR_LINK_STATE = 0x6
NCSI_CHANNEL_ATTR_ACTIVE = 0x7
NCSI_CHANNEL_ATTR_FORCED = 0x8
NCSI_CHANNEL_ATTR_VLAN_LIST = 0x9
NCSI_CHANNEL_ATTR_VLAN_ID = 0xa
)
type ScmTimestamping struct {
Ts [3]Timespec
}
const (
SOF_TIMESTAMPING_TX_HARDWARE = 0x1
SOF_TIMESTAMPING_TX_SOFTWARE = 0x2
SOF_TIMESTAMPING_RX_HARDWARE = 0x4
SOF_TIMESTAMPING_RX_SOFTWARE = 0x8
SOF_TIMESTAMPING_SOFTWARE = 0x10
SOF_TIMESTAMPING_SYS_HARDWARE = 0x20
SOF_TIMESTAMPING_RAW_HARDWARE = 0x40
SOF_TIMESTAMPING_OPT_ID = 0x80
SOF_TIMESTAMPING_TX_SCHED = 0x100
SOF_TIMESTAMPING_TX_ACK = 0x200
SOF_TIMESTAMPING_OPT_CMSG = 0x400
SOF_TIMESTAMPING_OPT_TSONLY = 0x800
SOF_TIMESTAMPING_OPT_STATS = 0x1000
SOF_TIMESTAMPING_OPT_PKTINFO = 0x2000
SOF_TIMESTAMPING_OPT_TX_SWHW = 0x4000
SOF_TIMESTAMPING_LAST = 0x4000
SOF_TIMESTAMPING_MASK = 0x7fff
SCM_TSTAMP_SND = 0x0
SCM_TSTAMP_SCHED = 0x1
SCM_TSTAMP_ACK = 0x2
)
type SockExtendedErr struct {
Errno uint32
Origin uint8
Type uint8
Code uint8
Pad uint8
Info uint32
Data uint32
}
type FanotifyEventMetadata struct {
Event_len uint32
Vers uint8
Reserved uint8
Metadata_len uint16
Mask uint64
Fd int32
Pid int32
}
type FanotifyResponse struct {
Fd int32
Response uint32
}
const (
CRYPTO_MSG_BASE = 0x10
CRYPTO_MSG_NEWALG = 0x10
CRYPTO_MSG_DELALG = 0x11
CRYPTO_MSG_UPDATEALG = 0x12
CRYPTO_MSG_GETALG = 0x13
CRYPTO_MSG_DELRNG = 0x14
CRYPTO_MSG_GETSTAT = 0x15
)
const (
CRYPTOCFGA_UNSPEC = 0x0
CRYPTOCFGA_PRIORITY_VAL = 0x1
CRYPTOCFGA_REPORT_LARVAL = 0x2
CRYPTOCFGA_REPORT_HASH = 0x3
CRYPTOCFGA_REPORT_BLKCIPHER = 0x4
CRYPTOCFGA_REPORT_AEAD = 0x5
CRYPTOCFGA_REPORT_COMPRESS = 0x6
CRYPTOCFGA_REPORT_RNG = 0x7
CRYPTOCFGA_REPORT_CIPHER = 0x8
CRYPTOCFGA_REPORT_AKCIPHER = 0x9
CRYPTOCFGA_REPORT_KPP = 0xa
CRYPTOCFGA_REPORT_ACOMP = 0xb
CRYPTOCFGA_STAT_LARVAL = 0xc
CRYPTOCFGA_STAT_HASH = 0xd
CRYPTOCFGA_STAT_BLKCIPHER = 0xe
CRYPTOCFGA_STAT_AEAD = 0xf
CRYPTOCFGA_STAT_COMPRESS = 0x10
CRYPTOCFGA_STAT_RNG = 0x11
CRYPTOCFGA_STAT_CIPHER = 0x12
CRYPTOCFGA_STAT_AKCIPHER = 0x13
CRYPTOCFGA_STAT_KPP = 0x14
CRYPTOCFGA_STAT_ACOMP = 0x15
)
type CryptoUserAlg struct {
Name [64]uint8
Driver_name [64]uint8
Module_name [64]uint8
Type uint32
Mask uint32
Refcnt uint32
Flags uint32
}
type CryptoStatAEAD struct {
Type [64]uint8
Encrypt_cnt uint64
Encrypt_tlen uint64
Decrypt_cnt uint64
Decrypt_tlen uint64
Err_cnt uint64
}
type CryptoStatAKCipher struct {
Type [64]uint8
Encrypt_cnt uint64
Encrypt_tlen uint64
Decrypt_cnt uint64
Decrypt_tlen uint64
Verify_cnt uint64
Sign_cnt uint64
Err_cnt uint64
}
type CryptoStatCipher struct {
Type [64]uint8
Encrypt_cnt uint64
Encrypt_tlen uint64
Decrypt_cnt uint64
Decrypt_tlen uint64
Err_cnt uint64
}
type CryptoStatCompress struct {
Type [64]uint8
Compress_cnt uint64
Compress_tlen uint64
Decompress_cnt uint64
Decompress_tlen uint64
Err_cnt uint64
}
type CryptoStatHash struct {
Type [64]uint8
Hash_cnt uint64
Hash_tlen uint64
Err_cnt uint64
}
type CryptoStatKPP struct {
Type [64]uint8
Setsecret_cnt uint64
Generate_public_key_cnt uint64
Compute_shared_secret_cnt uint64
Err_cnt uint64
}
type CryptoStatRNG struct {
Type [64]uint8
Generate_cnt uint64
Generate_tlen uint64
Seed_cnt uint64
Err_cnt uint64
}
type CryptoStatLarval struct {
Type [64]uint8
}
type CryptoReportLarval struct {
Type [64]uint8
}
type CryptoReportHash struct {
Type [64]uint8
Blocksize uint32
Digestsize uint32
}
type CryptoReportCipher struct {
Type [64]uint8
Blocksize uint32
Min_keysize uint32
Max_keysize uint32
}
type CryptoReportBlkCipher struct {
Type [64]uint8
Geniv [64]uint8
Blocksize uint32
Min_keysize uint32
Max_keysize uint32
Ivsize uint32
}
type CryptoReportAEAD struct {
Type [64]uint8
Geniv [64]uint8
Blocksize uint32
Maxauthsize uint32
Ivsize uint32
}
type CryptoReportComp struct {
Type [64]uint8
}
type CryptoReportRNG struct {
Type [64]uint8
Seedsize uint32
}
type CryptoReportAKCipher struct {
Type [64]uint8
}
type CryptoReportKPP struct {
Type [64]uint8
}
type CryptoReportAcomp struct {
Type [64]uint8
}
```
|
Michael Kurtiz Baldo Williams (born October 27, 1991) is a Filipino-American professional basketball player for the TNT Tropang Giga of the Philippine Basketball Association (PBA).
Collegiate career
In his senior year at Cal State Fullerton, he scored a collegiate high of 29 points to go along with 6 rebounds in a losing effort to UCSB Gauchos.
Professional career
After he became undrafted in 2014 NBA draft, Williams played for Sioux Falls Skyforce in NBA G League from 2014 to 2016, and in Canton Charge from 2016 to 2017.
He also played as a heritage import for Saigon Heat in ASEAN Basketball League from 2017 to 2018. He then played for the GenSan Warriors of Maharlika Pilipinas Basketball League from 2018 to 2019, wherein he averaged 15.9 points, 6.6 assists, 5.1 rebounds, and 1.1 steals per game.
Williams made a PBA finals record of 10 three-pointers in a 98–106 loss of TNT Tropang Giga to the Magnolia Hotshots in Game 3 of the 2021 PBA Philippine Cup Finals.
PBA career statistics
As of the end of 2022–23 season
Season-by-season averages
|-
| align=left |
| align=left | TNT
| 36 || 36.3 || .410 || .376 || .730 || 4.4 || 4.4 || .9 || .1 || 19.5
|-
| align=left |
| align=left | TNT
| 51 || 35.5 || .397 || .367 || .642 || 3.9 || 4.1 || .7 || .1 || 18.4
|- class="sortbottom"
| style="text-align:center;" colspan="2"|Career
| 87 || 35.8 || .403 || .371 || .677|| 4.1 || 4.2 || .8 || .1 || 18.9
Notes
References
External links
PBA.ph profile
NBA G League profile
Cal State Fullerton Titans bio
San Francisco Dons bio
1991 births
Living people
21st-century African-American sportspeople
African-American basketball players
American men's basketball players
American sportspeople of Filipino descent
Basketball players from Los Angeles
Cal State Fullerton Titans men's basketball players
Canton Charge players
Filipino men's basketball players
Maharlika Pilipinas Basketball League players
Philippine Basketball Association All-Stars
Point guards
Saigon Heat players
San Francisco Dons men's basketball players
Shooting guards
Sioux Falls Skyforce players
TNT Tropang Giga draft picks
TNT Tropang Giga players
|
Earl of Kimberley, of Kimberley in the County of Norfolk, is a title in the Peerage of the United Kingdom. It was created in 1866 for the prominent Liberal politician John Wodehouse, 3rd Baron Wodehouse. During his long political career, he notably held office as Lord Lieutenant of Ireland, Secretary of State for the Colonies, Secretary of State for India and Secretary of State for Foreign Affairs. He was succeeded by his son, the second Earl. At first a Liberal like his father, he later joined the Labour Party, becoming the first Labour member of the House of Lords. His eldest son, the third Earl, represented Norfolk Mid in the House of Commons as a Liberal. Since 2002, the titles are held by the latter's grandson, the fifth Earl.
Background
The title of Baron Wodehouse, of Kimberley in the County of Norfolk, was created in the Peerage of Great Britain in 1797 for Sir John Wodehouse, 6th Baronet, of Wilberhall. He had previously represented Norfolk in Parliament. His son, the second Baron, sat as Member of Parliament for Great Bedwyn and Marlborough. He was succeeded by his grandson, the aforementioned third Baron (son of the Hon. Henry Wodehouse), who was created Earl of Kimberley in 1866.
The Wodehouse Baronetcy, of Wilberhall in the County of Norfolk, was created in the Baronetage of England in 1611 for Philip Wodehouse, previously Member of Parliament for Castle Rising. His son, the second Baronet, was Member of Parliament for Thetford. He was succeeded by his son, the third Baronet, who represented Thetford as well as Norfolk in the House of Commons. His grandson, the fourth Baronet, was also Member of Parliament for these constituencies. His son, the fifth Baronet, represented Norfolk in Parliament. He was succeeded by his son, the aforementioned sixth Baronet, who was elevated to the peerage in 1797.
Several other members of the Wodehouse family have also gained distinction. The author P. G. Wodehouse was the great-grandson of the Reverend Philip Wodehouse, second son of the fifth Baronet. The politician Edmond Wodehouse was the son of Thomas Wodehouse, third son of the fifth Baronet. His eldest son was the colonial administrator Sir Philip Wodehouse, Governor of Bombay from 1872 to 1877. Sir Philip Wodehouse's son Edmond Wodehouse represented Bath in the House of Commons as a Unionist. The Hon. Armine Wodehouse, younger son of the first Earl, was a civil servant and Liberal politician.
The family seat is Hailstone House, near Cricklade, Wiltshire.
Wodehouse Baronets, of Wilberhall (1611)
Sir Philip Wodehouse, 1st Baronet (d. 1623)
Sir Thomas Wodehouse, 2nd Baronet (c. 1585–1658)
Sir Philip Wodehouse, 3rd Baronet (1608–1681)
Sir Thomas Wodehouse (d. 1661)
Sir John Wodehouse, 4th Baronet (1669–1754)
William Wodehouse (c. 1706–1737)
Sir Armine Wodehouse, 5th Baronet (c. 1714–1777)
Sir John Wodehouse, 6th Baronet (1741–1834) (created Baron Wodehouse in 1797)
Barons Wodehouse (1797)
John Wodehouse, 1st Baron Wodehouse (1741–1834)
John Wodehouse, 2nd Baron Wodehouse (1770–1846)
The Hon. Henry Wodehouse (1799–1834)
John Wodehouse, 3rd Baron Wodehouse (1826–1902) (created Earl of Kimberley in 1866)
Earls of Kimberley (1866)
John Wodehouse, 1st Earl of Kimberley (1826–1902)
John Wodehouse, 2nd Earl of Kimberley (1848–1932)
John Wodehouse, 3rd Earl of Kimberley (1883–1941)
John Wodehouse, 4th Earl of Kimberley (1924–2002)
John Armine Wodehouse, 5th Earl of Kimberley (b. 1951)
The heir apparent is the present holder's only son, David Simon John Wodehouse, Lord Wodehouse (b. 1978), whose heir is his son Hon. Jasper John Wodehouse (b. 2017).
References
Cited books
Earldoms in the Peerage of the United Kingdom
1611 establishments in England
Noble titles created in 1866
Earls of Kimberley
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package io.material.catalog.bottomsheet;
import io.material.catalog.R;
import android.app.Dialog;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.LayoutRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.view.WindowInsetsCompat;
import com.google.android.material.bottomsheet.BottomSheetBehavior;
import com.google.android.material.bottomsheet.BottomSheetDialog;
import com.google.android.material.bottomsheet.BottomSheetDialogFragment;
import com.google.android.material.internal.ViewUtils;
import io.material.catalog.feature.DemoFragment;
import io.material.catalog.windowpreferences.WindowPreferencesManager;
/**
* A fragment that displays the a BottomSheet demo with vertical scrollable content for the Catalog
* app.
*/
public class BottomSheetScrollableContentDemoFragment extends DemoFragment {
@Override
public View onCreateDemoView(
LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
View view = layoutInflater.inflate(getDemoContent(), viewGroup, false /* attachToRoot */);
View button = view.findViewById(R.id.bottomsheet_button);
button.setOnClickListener(v -> new BottomSheet().show(getParentFragmentManager(), ""));
return view;
}
@LayoutRes
protected int getDemoContent() {
return R.layout.cat_bottomsheet_scrollable_content_fragment;
}
/** A custom bottom sheet dialog fragment. */
@SuppressWarnings("RestrictTo")
public static class BottomSheet extends BottomSheetDialogFragment {
@NonNull
@Override
public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
// Set up BottomSheetDialog
BottomSheetDialog bottomSheetDialog =
new BottomSheetDialog(
getContext(), R.style.ThemeOverlay_Catalog_BottomSheetDialog_Scrollable);
new WindowPreferencesManager(requireContext()).applyEdgeToEdgePreference(bottomSheetDialog.getWindow());
bottomSheetDialog.setContentView(R.layout.cat_bottomsheet_scrollable_content);
View bottomSheetInternal = bottomSheetDialog.findViewById(R.id.design_bottom_sheet);
BottomSheetBehavior.from(bottomSheetInternal).setPeekHeight(400);
View bottomSheetContent = bottomSheetInternal.findViewById(R.id.bottom_drawer_2);
ViewUtils.doOnApplyWindowInsets(bottomSheetContent, (v, insets, initialPadding) -> {
// Add the inset in the inner NestedScrollView instead to make the edge-to-edge behavior
// consistent - i.e., the extra padding will only show at the bottom of all content, i.e.,
// only when you can no longer scroll down to show more content.
bottomSheetContent.setPaddingRelative(
initialPadding.start,
initialPadding.top,
initialPadding.end,
initialPadding.bottom + insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom);
return insets;
});
return bottomSheetDialog;
}
}
}
```
|
The Volkswagen Concept A was a concept car created by German automobile manufacturer Volkswagen. It was introduced at the 2006 Geneva Motor Show. The Concept A is a cross between a coupé and a crossover sports utility vehicle.
Description
The Concept A was powered by an I4 twincharger (TSI) engine with around 150 horsepower. It has all-wheel drive (AWD) with 4Motion and six gears with automatic transmission. The car's design was sporty but rugged. It is sometimes claimed as a cross between a coupé and a crossover sports utility vehicle because of this styling and design.
A production version of the Concept A, the Tiguan Compact SUV, was expected for sale in the end of 2008. It was launched at the end of 2007 at the Frankfurt Motor Show.
References
All-wheel-drive vehicles
Cars introduced in 2006
Compact sport utility vehicles
Crossover sport utility vehicles
Concept A
|
```xml
<dict>
<key>CommonPeripheralDSP</key>
<array>
<dict>
<key>DeviceID</key>
<integer>0</integer>
<key>DeviceType</key>
<string>Headphone</string>
</dict>
<dict>
<key>DeviceID</key>
<integer>0</integer>
<key>DeviceType</key>
<string>Microphone</string>
</dict>
</array>
<key>PathMaps</key>
<array>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>18</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>1</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Boost</key>
<integer>1</integer>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>2</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>3</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>0</integer>
</dict>
</array>
<key>HardwareDownmixToMono</key>
<true/>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>4</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Boost</key>
<integer>1</integer>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>5</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>6</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Boost</key>
<integer>1</integer>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>7</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>8</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>9</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
<key>RetaskDetectDelegate</key>
<integer>9</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>10</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>11</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>12</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>13</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
<key>RetaskDetectDelegate</key>
<integer>9</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>14</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>15</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>16</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>17</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Boost</key>
<integer>28</integer>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>18</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>19</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>20</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>22</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>23</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>24</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>25</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Boost</key>
<integer>28</integer>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>26</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>27</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>27</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>28</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>29</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>30</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>27</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>40</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>41</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>42</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>43</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>44</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
<key>RetaskDetectDelegate</key>
<integer>9</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>45</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>46</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>47</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>48</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>49</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>51</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>60</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>4206</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>4207</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>282984455</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>8800</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>8801</integer>
</dict>
</array>
</dict>
```
|
```html
<!DOCTYPE html>
<html xmlns="path_to_url"><head><title>S (owl.Owl_algodiff_primal_ops.S)</title><meta charset="utf-8"/><link rel="stylesheet" href="../../../odoc.support/odoc.css"/><meta name="generator" content="odoc 2.4.2"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../odoc.support/highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body class="odoc"><nav class="odoc-nav"><a href="../index.html">Up</a> <a href="../../index.html">owl</a> » <a href="../index.html">Owl_algodiff_primal_ops</a> » S</nav><header class="odoc-preamble"><h1>Module <code><span>Owl_algodiff_primal_ops.S</span></code></h1></header><div class="odoc-content"><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../../Owl_dense_ndarray/S/index.html">Owl_dense_ndarray.S</a> <span class="keyword">end</span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../../Owl_dense_ndarray_s/index.html">Owl_dense_ndarray_s</a> <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec type anchored" id="type-elt"><a href="#type-elt" class="anchor"></a><code><span><span class="keyword">type</span> elt</span><span> = float</span></code></div></div><div class="odoc-spec"><div class="spec type anchored" id="type-arr"><a href="#type-arr" class="anchor"></a><code><span><span class="keyword">type</span> arr</span><span> =
<span><span>(float, <span class="xref-unresolved">Stdlib</span>.Bigarray.float32_elt, <span class="xref-unresolved">Stdlib</span>.Bigarray.c_layout)</span>
<span class="xref-unresolved">Stdlib</span>.Bigarray.Genarray.t</span></span></code></div></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../Owl_dense_ndarray_intf/module-type-Common/index.html">Owl_dense_ndarray_intf.Common</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../Owl_dense_ndarray_intf/module-type-Common/index.html#type-elt">elt</a> := <a href="#type-elt">elt</a></span> <span class="keyword">and</span> <span><span class="keyword">type</span> <a href="../../Owl_dense_ndarray_intf/module-type-Common/index.html#type-arr">arr</a> := <a href="#type-arr">arr</a></span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-Common/index.html">Owl_base_dense_ndarray_intf.Common</a>
<span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-Common/index.html#type-elt">elt</a> := <a href="#type-elt">elt</a></span>
<span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-Common/index.html#type-arr">arr</a> := <a href="#type-arr">arr</a></span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-number"><a href="#val-number" class="anchor"></a><code><span><span class="keyword">val</span> number : <a href="../../../owl-base/Owl_types_common/index.html#type-number">Owl_types_common.number</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-empty"><a href="#val-empty" class="anchor"></a><code><span><span class="keyword">val</span> empty : <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-zeros"><a href="#val-zeros" class="anchor"></a><code><span><span class="keyword">val</span> zeros : <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ones"><a href="#val-ones" class="anchor"></a><code><span><span class="keyword">val</span> ones : <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-create"><a href="#val-create" class="anchor"></a><code><span><span class="keyword">val</span> create : <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init"><a href="#val-init" class="anchor"></a><code><span><span class="keyword">val</span> init : <span><span>int array</span> <span class="arrow">-></span></span> <span><span>(<span>int <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-init_nd"><a href="#val-init_nd" class="anchor"></a><code><span><span class="keyword">val</span> init_nd : <span><span>int array</span> <span class="arrow">-></span></span> <span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sequential"><a href="#val-sequential" class="anchor"></a><code><span><span class="keyword">val</span> sequential : <span><span class="optlabel">?a</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?step</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uniform"><a href="#val-uniform" class="anchor"></a><code><span><span class="keyword">val</span> uniform : <span><span class="optlabel">?a</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?b</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-gaussian"><a href="#val-gaussian" class="anchor"></a><code><span><span class="keyword">val</span> gaussian : <span><span class="optlabel">?mu</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?sigma</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bernoulli"><a href="#val-bernoulli" class="anchor"></a><code><span><span class="keyword">val</span> bernoulli : <span><span class="optlabel">?p</span>:float <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-shape"><a href="#val-shape" class="anchor"></a><code><span><span class="keyword">val</span> shape : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-numel"><a href="#val-numel" class="anchor"></a><code><span><span class="keyword">val</span> numel : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-strides"><a href="#val-strides" class="anchor"></a><code><span><span class="keyword">val</span> strides : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int array</span></span></code></div><div class="spec-doc"><p>Refer to :doc:`owl_dense_ndarray_generic`</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-slice_size"><a href="#val-slice_size" class="anchor"></a><code><span><span class="keyword">val</span> slice_size : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int array</span></span></code></div><div class="spec-doc"><p>Refer to :doc:`owl_dense_ndarray_generic`</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get"><a href="#val-get" class="anchor"></a><code><span><span class="keyword">val</span> get : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set"><a href="#val-set" class="anchor"></a><code><span><span class="keyword">val</span> set : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_slice"><a href="#val-get_slice" class="anchor"></a><code><span><span class="keyword">val</span> get_slice : <span><span><span>int list</span> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_slice"><a href="#val-set_slice" class="anchor"></a><code><span><span class="keyword">val</span> set_slice : <span><span><span>int list</span> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy"><a href="#val-copy" class="anchor"></a><code><span><span class="keyword">val</span> copy : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy_"><a href="#val-copy_" class="anchor"></a><code><span><span class="keyword">val</span> copy_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reset"><a href="#val-reset" class="anchor"></a><code><span><span class="keyword">val</span> reset : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reshape"><a href="#val-reshape" class="anchor"></a><code><span><span class="keyword">val</span> reshape : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flatten"><a href="#val-flatten" class="anchor"></a><code><span><span class="keyword">val</span> flatten : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reverse"><a href="#val-reverse" class="anchor"></a><code><span><span class="keyword">val</span> reverse : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tile"><a href="#val-tile" class="anchor"></a><code><span><span class="keyword">val</span> tile : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-repeat"><a href="#val-repeat" class="anchor"></a><code><span><span class="keyword">val</span> repeat : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concatenate"><a href="#val-concatenate" class="anchor"></a><code><span><span class="keyword">val</span> concatenate : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span><a href="#type-arr">arr</a> array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-stack"><a href="#val-stack" class="anchor"></a><code><span><span class="keyword">val</span> stack : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span><a href="#type-arr">arr</a> array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-squeeze"><a href="#val-squeeze" class="anchor"></a><code><span><span class="keyword">val</span> squeeze : <span><span class="optlabel">?axis</span>:<span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expand"><a href="#val-expand" class="anchor"></a><code><span><span class="keyword">val</span> expand : <span><span class="optlabel">?hi</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split"><a href="#val-split" class="anchor"></a><code><span><span class="keyword">val</span> split : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-draw"><a href="#val-draw" class="anchor"></a><code><span><span class="keyword">val</span> draw : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a> * <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pad"><a href="#val-pad" class="anchor"></a><code><span><span class="keyword">val</span> pad : <span><span class="optlabel">?v</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span><span>int list</span> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-one_hot"><a href="#val-one_hot" class="anchor"></a><code><span><span class="keyword">val</span> one_hot : <span>int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-print"><a href="#val-print" class="anchor"></a><code><span><span class="keyword">val</span> print :
<span><span class="optlabel">?max_row</span>:int <span class="arrow">-></span></span>
<span><span class="optlabel">?max_col</span>:int <span class="arrow">-></span></span>
<span><span class="optlabel">?header</span>:bool <span class="arrow">-></span></span>
<span><span class="optlabel">?fmt</span>:<span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> string)</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span><span class="keyword">val</span> abs : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span><span class="keyword">val</span> neg : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-floor"><a href="#val-floor" class="anchor"></a><code><span><span class="keyword">val</span> floor : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ceil"><a href="#val-ceil" class="anchor"></a><code><span><span class="keyword">val</span> ceil : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-round"><a href="#val-round" class="anchor"></a><code><span><span class="keyword">val</span> round : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sqr"><a href="#val-sqr" class="anchor"></a><code><span><span class="keyword">val</span> sqr : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sqrt"><a href="#val-sqrt" class="anchor"></a><code><span><span class="keyword">val</span> sqrt : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log"><a href="#val-log" class="anchor"></a><code><span><span class="keyword">val</span> log : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log2"><a href="#val-log2" class="anchor"></a><code><span><span class="keyword">val</span> log2 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log10"><a href="#val-log10" class="anchor"></a><code><span><span class="keyword">val</span> log10 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp"><a href="#val-exp" class="anchor"></a><code><span><span class="keyword">val</span> exp : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sin"><a href="#val-sin" class="anchor"></a><code><span><span class="keyword">val</span> sin : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cos"><a href="#val-cos" class="anchor"></a><code><span><span class="keyword">val</span> cos : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tan"><a href="#val-tan" class="anchor"></a><code><span><span class="keyword">val</span> tan : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sinh"><a href="#val-sinh" class="anchor"></a><code><span><span class="keyword">val</span> sinh : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cosh"><a href="#val-cosh" class="anchor"></a><code><span><span class="keyword">val</span> cosh : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tanh"><a href="#val-tanh" class="anchor"></a><code><span><span class="keyword">val</span> tanh : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-asin"><a href="#val-asin" class="anchor"></a><code><span><span class="keyword">val</span> asin : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-acos"><a href="#val-acos" class="anchor"></a><code><span><span class="keyword">val</span> acos : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atan"><a href="#val-atan" class="anchor"></a><code><span><span class="keyword">val</span> atan : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-asinh"><a href="#val-asinh" class="anchor"></a><code><span><span class="keyword">val</span> asinh : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-acosh"><a href="#val-acosh" class="anchor"></a><code><span><span class="keyword">val</span> acosh : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atanh"><a href="#val-atanh" class="anchor"></a><code><span><span class="keyword">val</span> atanh : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min"><a href="#val-min" class="anchor"></a><code><span><span class="keyword">val</span> min : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max"><a href="#val-max" class="anchor"></a><code><span><span class="keyword">val</span> max : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sum"><a href="#val-sum" class="anchor"></a><code><span><span class="keyword">val</span> sum : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sum_reduce"><a href="#val-sum_reduce" class="anchor"></a><code><span><span class="keyword">val</span> sum_reduce : <span><span class="optlabel">?axis</span>:<span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min'"><a href="#val-min'" class="anchor"></a><code><span><span class="keyword">val</span> min' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max'"><a href="#val-max'" class="anchor"></a><code><span><span class="keyword">val</span> max' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sum'"><a href="#val-sum'" class="anchor"></a><code><span><span class="keyword">val</span> sum' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pow"><a href="#val-pow" class="anchor"></a><code><span><span class="keyword">val</span> pow : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_pow"><a href="#val-scalar_pow" class="anchor"></a><code><span><span class="keyword">val</span> scalar_pow : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pow_scalar"><a href="#val-pow_scalar" class="anchor"></a><code><span><span class="keyword">val</span> pow_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add"><a href="#val-add" class="anchor"></a><code><span><span class="keyword">val</span> add : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub"><a href="#val-sub" class="anchor"></a><code><span><span class="keyword">val</span> sub : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mul"><a href="#val-mul" class="anchor"></a><code><span><span class="keyword">val</span> mul : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-div"><a href="#val-div" class="anchor"></a><code><span><span class="keyword">val</span> div : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_scalar"><a href="#val-add_scalar" class="anchor"></a><code><span><span class="keyword">val</span> add_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub_scalar"><a href="#val-sub_scalar" class="anchor"></a><code><span><span class="keyword">val</span> sub_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mul_scalar"><a href="#val-mul_scalar" class="anchor"></a><code><span><span class="keyword">val</span> mul_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-div_scalar"><a href="#val-div_scalar" class="anchor"></a><code><span><span class="keyword">val</span> div_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_add"><a href="#val-scalar_add" class="anchor"></a><code><span><span class="keyword">val</span> scalar_add : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_sub"><a href="#val-scalar_sub" class="anchor"></a><code><span><span class="keyword">val</span> scalar_sub : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_mul"><a href="#val-scalar_mul" class="anchor"></a><code><span><span class="keyword">val</span> scalar_mul : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_div"><a href="#val-scalar_div" class="anchor"></a><code><span><span class="keyword">val</span> scalar_div : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fma"><a href="#val-fma" class="anchor"></a><code><span><span class="keyword">val</span> fma : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><h6 id="iterate-array-elements"><a href="#iterate-array-elements" class="anchor"></a>Iterate array elements</h6><div class="odoc-spec"><div class="spec value anchored" id="val-iteri"><a href="#val-iteri" class="anchor"></a><code><span><span class="keyword">val</span> iteri : <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter"><a href="#val-iter" class="anchor"></a><code><span><span class="keyword">val</span> iter : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi"><a href="#val-mapi" class="anchor"></a><code><span><span class="keyword">val</span> mapi : <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map"><a href="#val-map" class="anchor"></a><code><span><span class="keyword">val</span> map : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filteri"><a href="#val-filteri" class="anchor"></a><code><span><span class="keyword">val</span> filteri : <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter"><a href="#val-filter" class="anchor"></a><code><span><span class="keyword">val</span> filter : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-foldi"><a href="#val-foldi" class="anchor"></a><code><span><span class="keyword">val</span> foldi : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold"><a href="#val-fold" class="anchor"></a><code><span><span class="keyword">val</span> fold : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scani"><a href="#val-scani" class="anchor"></a><code><span><span class="keyword">val</span> scani : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scan"><a href="#val-scan" class="anchor"></a><code><span><span class="keyword">val</span> scan : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><h6 id="examination-&-comparison"><a href="#examination-&-comparison" class="anchor"></a>Examination & Comparison</h6><div class="odoc-spec"><div class="spec value anchored" id="val-exists"><a href="#val-exists" class="anchor"></a><code><span><span class="keyword">val</span> exists : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-not_exists"><a href="#val-not_exists" class="anchor"></a><code><span><span class="keyword">val</span> not_exists : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-for_all"><a href="#val-for_all" class="anchor"></a><code><span><span class="keyword">val</span> for_all : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_zero"><a href="#val-is_zero" class="anchor"></a><code><span><span class="keyword">val</span> is_zero : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_positive"><a href="#val-is_positive" class="anchor"></a><code><span><span class="keyword">val</span> is_positive : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_negative"><a href="#val-is_negative" class="anchor"></a><code><span><span class="keyword">val</span> is_negative : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_nonpositive"><a href="#val-is_nonpositive" class="anchor"></a><code><span><span class="keyword">val</span> is_nonpositive : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_nonnegative"><a href="#val-is_nonnegative" class="anchor"></a><code><span><span class="keyword">val</span> is_nonnegative : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-is_normal"><a href="#val-is_normal" class="anchor"></a><code><span><span class="keyword">val</span> is_normal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-not_nan"><a href="#val-not_nan" class="anchor"></a><code><span><span class="keyword">val</span> not_nan : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-not_inf"><a href="#val-not_inf" class="anchor"></a><code><span><span class="keyword">val</span> not_inf : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span><span class="keyword">val</span> equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-not_equal"><a href="#val-not_equal" class="anchor"></a><code><span><span class="keyword">val</span> not_equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-greater"><a href="#val-greater" class="anchor"></a><code><span><span class="keyword">val</span> greater : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-less"><a href="#val-less" class="anchor"></a><code><span><span class="keyword">val</span> less : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-greater_equal"><a href="#val-greater_equal" class="anchor"></a><code><span><span class="keyword">val</span> greater_equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-less_equal"><a href="#val-less_equal" class="anchor"></a><code><span><span class="keyword">val</span> less_equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_equal"><a href="#val-elt_equal" class="anchor"></a><code><span><span class="keyword">val</span> elt_equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_not_equal"><a href="#val-elt_not_equal" class="anchor"></a><code><span><span class="keyword">val</span> elt_not_equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less"><a href="#val-elt_less" class="anchor"></a><code><span><span class="keyword">val</span> elt_less : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater"><a href="#val-elt_greater" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less_equal"><a href="#val-elt_less_equal" class="anchor"></a><code><span><span class="keyword">val</span> elt_less_equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater_equal"><a href="#val-elt_greater_equal" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater_equal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-equal_scalar"><a href="#val-equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-not_equal_scalar"><a href="#val-not_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> not_equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-less_scalar"><a href="#val-less_scalar" class="anchor"></a><code><span><span class="keyword">val</span> less_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-greater_scalar"><a href="#val-greater_scalar" class="anchor"></a><code><span><span class="keyword">val</span> greater_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-less_equal_scalar"><a href="#val-less_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> less_equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-greater_equal_scalar"><a href="#val-greater_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> greater_equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_equal_scalar"><a href="#val-elt_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> elt_equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_not_equal_scalar"><a href="#val-elt_not_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> elt_not_equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less_scalar"><a href="#val-elt_less_scalar" class="anchor"></a><code><span><span class="keyword">val</span> elt_less_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater_scalar"><a href="#val-elt_greater_scalar" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less_equal_scalar"><a href="#val-elt_less_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> elt_less_equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater_equal_scalar"><a href="#val-elt_greater_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater_equal_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-row_num"><a href="#val-row_num" class="anchor"></a><code><span><span class="keyword">val</span> row_num : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-col_num"><a href="#val-col_num" class="anchor"></a><code><span><span class="keyword">val</span> col_num : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-row"><a href="#val-row" class="anchor"></a><code><span><span class="keyword">val</span> row : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rows"><a href="#val-rows" class="anchor"></a><code><span><span class="keyword">val</span> rows : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy_row_to"><a href="#val-copy_row_to" class="anchor"></a><code><span><span class="keyword">val</span> copy_row_to : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-copy_col_to"><a href="#val-copy_col_to" class="anchor"></a><code><span><span class="keyword">val</span> copy_col_to : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-diag"><a href="#val-diag" class="anchor"></a><code><span><span class="keyword">val</span> diag : <span><span class="optlabel">?k</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose"><a href="#val-transpose" class="anchor"></a><code><span><span class="keyword">val</span> transpose : <span><span class="optlabel">?axis</span>:<span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_rows"><a href="#val-to_rows" class="anchor"></a><code><span><span class="keyword">val</span> to_rows : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_rows"><a href="#val-of_rows" class="anchor"></a><code><span><span class="keyword">val</span> of_rows : <span><span><a href="#type-arr">arr</a> array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_cols"><a href="#val-to_cols" class="anchor"></a><code><span><span class="keyword">val</span> to_cols : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_cols"><a href="#val-of_cols" class="anchor"></a><code><span><span class="keyword">val</span> of_cols : <span><span><a href="#type-arr">arr</a> array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_array"><a href="#val-of_array" class="anchor"></a><code><span><span class="keyword">val</span> of_array : <span><span><a href="#type-elt">elt</a> array</span> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-of_arrays"><a href="#val-of_arrays" class="anchor"></a><code><span><span class="keyword">val</span> of_arrays : <span><span><span><a href="#type-elt">elt</a> array</span> array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div></details></div><h6 id="create-n-dimensional-array"><a href="#create-n-dimensional-array" class="anchor"></a>Create N-dimensional array</h6><div class="odoc-spec"><div class="spec value anchored" id="val-linspace"><a href="#val-linspace" class="anchor"></a><code><span><span class="keyword">val</span> linspace : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div><div class="spec-doc"><p><code>linspace k 0. 9. 10</code> ...</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-logspace"><a href="#val-logspace" class="anchor"></a><code><span><span class="keyword">val</span> logspace : <span><span class="optlabel">?base</span>:float <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div><div class="spec-doc"><p><code>logspace k 0. 9. 10</code> ...</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-unit_basis"><a href="#val-unit_basis" class="anchor"></a><code><span><span class="keyword">val</span> unit_basis : <span>int <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div><div class="spec-doc"><p><code>unit_basis k n i</code> returns a unit basis vector with <code>i</code>th element set to 1.</p></div></div><h6 id="obtain-basic-properties"><a href="#obtain-basic-properties" class="anchor"></a>Obtain basic properties</h6><div class="odoc-spec"><div class="spec value anchored" id="val-num_dims"><a href="#val-num_dims" class="anchor"></a><code><span><span class="keyword">val</span> num_dims : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nth_dim"><a href="#val-nth_dim" class="anchor"></a><code><span><span class="keyword">val</span> nth_dim : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-nnz"><a href="#val-nnz" class="anchor"></a><code><span><span class="keyword">val</span> nnz : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-density"><a href="#val-density" class="anchor"></a><code><span><span class="keyword">val</span> density : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> float</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-size_in_bytes"><a href="#val-size_in_bytes" class="anchor"></a><code><span><span class="keyword">val</span> size_in_bytes : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> int</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-same_shape"><a href="#val-same_shape" class="anchor"></a><code><span><span class="keyword">val</span> same_shape : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-same_data"><a href="#val-same_data" class="anchor"></a><code><span><span class="keyword">val</span> same_data : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ind"><a href="#val-ind" class="anchor"></a><code><span><span class="keyword">val</span> ind : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-i1d"><a href="#val-i1d" class="anchor"></a><code><span><span class="keyword">val</span> i1d : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> int</span></code></div></div><h6 id="manipulate-a-n-dimensional-array"><a href="#manipulate-a-n-dimensional-array" class="anchor"></a>Manipulate a N-dimensional array</h6><div class="odoc-spec"><div class="spec value anchored" id="val-get_index"><a href="#val-get_index" class="anchor"></a><code><span><span class="keyword">val</span> get_index : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><span>int array</span> array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_index"><a href="#val-set_index" class="anchor"></a><code><span><span class="keyword">val</span> set_index : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><span>int array</span> array</span> <span class="arrow">-></span></span> <span><span><a href="#type-elt">elt</a> array</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_fancy"><a href="#val-get_fancy" class="anchor"></a><code><span><span class="keyword">val</span> get_fancy : <span><span><a href="../../../owl-base/Owl_types/index.html#type-index">Owl_types.index</a> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_fancy"><a href="#val-set_fancy" class="anchor"></a><code><span><span class="keyword">val</span> set_fancy : <span><span><a href="../../../owl-base/Owl_types/index.html#type-index">Owl_types.index</a> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub_left"><a href="#val-sub_left" class="anchor"></a><code><span><span class="keyword">val</span> sub_left : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub_ndarray"><a href="#val-sub_ndarray" class="anchor"></a><code><span><span class="keyword">val</span> sub_ndarray : <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-slice_left"><a href="#val-slice_left" class="anchor"></a><code><span><span class="keyword">val</span> slice_left : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fill"><a href="#val-fill" class="anchor"></a><code><span><span class="keyword">val</span> fill : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-resize"><a href="#val-resize" class="anchor"></a><code><span><span class="keyword">val</span> resize : <span><span class="optlabel">?head</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-flip"><a href="#val-flip" class="anchor"></a><code><span><span class="keyword">val</span> flip : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-rotate"><a href="#val-rotate" class="anchor"></a><code><span><span class="keyword">val</span> rotate : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-swap"><a href="#val-swap" class="anchor"></a><code><span><span class="keyword">val</span> swap : <span>int <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_vertical"><a href="#val-concat_vertical" class="anchor"></a><code><span><span class="keyword">val</span> concat_vertical : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_horizontal"><a href="#val-concat_horizontal" class="anchor"></a><code><span><span class="keyword">val</span> concat_horizontal : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-concat_vh"><a href="#val-concat_vh" class="anchor"></a><code><span><span class="keyword">val</span> concat_vh : <span><span><span><a href="#type-arr">arr</a> array</span> array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-split_vh"><a href="#val-split_vh" class="anchor"></a><code><span><span class="keyword">val</span> split_vh : <span><span><span><span>(int * int)</span> array</span> array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><a href="#type-arr">arr</a> array</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dropout"><a href="#val-dropout" class="anchor"></a><code><span><span class="keyword">val</span> dropout : <span><span class="optlabel">?rate</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-top"><a href="#val-top" class="anchor"></a><code><span><span class="keyword">val</span> top : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><span>int array</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bottom"><a href="#val-bottom" class="anchor"></a><code><span><span class="keyword">val</span> bottom : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><span>int array</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort"><a href="#val-sort" class="anchor"></a><code><span><span class="keyword">val</span> sort : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort1"><a href="#val-sort1" class="anchor"></a><code><span><span class="keyword">val</span> sort1 : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-argsort"><a href="#val-argsort" class="anchor"></a><code><span><span class="keyword">val</span> argsort :
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>(int64, <span class="xref-unresolved">Stdlib</span>.Bigarray.int64_elt, <span class="xref-unresolved">Stdlib</span>.Bigarray.c_layout)</span>
<span class="xref-unresolved">Stdlib</span>.Bigarray.Genarray.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mmap"><a href="#val-mmap" class="anchor"></a><code><span><span class="keyword">val</span> mmap : <span><span class="xref-unresolved">Unix</span>.file_descr <span class="arrow">-></span></span> <span><span class="optlabel">?pos</span>:int64 <span class="arrow">-></span></span> <span>bool <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><h6 id="iterate-array-elements_2"><a href="#iterate-array-elements_2" class="anchor"></a>Iterate array elements</h6><div class="odoc-spec"><div class="spec value anchored" id="val-iter2i"><a href="#val-iter2i" class="anchor"></a><code><span><span class="keyword">val</span> iter2i : <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter2"><a href="#val-iter2" class="anchor"></a><code><span><span class="keyword">val</span> iter2 : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2i"><a href="#val-map2i" class="anchor"></a><code><span><span class="keyword">val</span> map2i : <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2"><a href="#val-map2" class="anchor"></a><code><span><span class="keyword">val</span> map2 : <span><span>(<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri_nd"><a href="#val-iteri_nd" class="anchor"></a><code><span><span class="keyword">val</span> iteri_nd : <span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi_nd"><a href="#val-mapi_nd" class="anchor"></a><code><span><span class="keyword">val</span> mapi_nd : <span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-foldi_nd"><a href="#val-foldi_nd" class="anchor"></a><code><span><span class="keyword">val</span> foldi_nd :
<span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span>
<span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span>
<span><a href="#type-elt">elt</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scani_nd"><a href="#val-scani_nd" class="anchor"></a><code><span><span class="keyword">val</span> scani_nd : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filteri_nd"><a href="#val-filteri_nd" class="anchor"></a><code><span><span class="keyword">val</span> filteri_nd : <span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter2i_nd"><a href="#val-iter2i_nd" class="anchor"></a><code><span><span class="keyword">val</span> iter2i_nd : <span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map2i_nd"><a href="#val-map2i_nd" class="anchor"></a><code><span><span class="keyword">val</span> map2i_nd : <span><span>(<span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iteri_slice"><a href="#val-iteri_slice" class="anchor"></a><code><span><span class="keyword">val</span> iteri_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iter_slice"><a href="#val-iter_slice" class="anchor"></a><code><span><span class="keyword">val</span> iter_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mapi_slice"><a href="#val-mapi_slice" class="anchor"></a><code><span><span class="keyword">val</span> mapi_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span class="type-var">'c</span>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-map_slice"><a href="#val-map_slice" class="anchor"></a><code><span><span class="keyword">val</span> map_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span class="type-var">'c</span>)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filteri_slice"><a href="#val-filteri_slice" class="anchor"></a><code><span><span class="keyword">val</span> filteri_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span>int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-filter_slice"><a href="#val-filter_slice" class="anchor"></a><code><span><span class="keyword">val</span> filter_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool)</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-foldi_slice"><a href="#val-foldi_slice" class="anchor"></a><code><span><span class="keyword">val</span> foldi_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span>int <span class="arrow">-></span></span> <span><span class="type-var">'c</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span class="type-var">'c</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span class="type-var">'c</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fold_slice"><a href="#val-fold_slice" class="anchor"></a><code><span><span class="keyword">val</span> fold_slice : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span>(<span><span class="type-var">'c</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span class="type-var">'c</span>)</span> <span class="arrow">-></span></span> <span><span class="type-var">'c</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span class="type-var">'c</span></span></code></div></div><h6 id="examine-array-elements-or-compare-two-arrays"><a href="#examine-array-elements-or-compare-two-arrays" class="anchor"></a>Examine array elements or compare two arrays</h6><h6 id="input/output-functions"><a href="#input/output-functions" class="anchor"></a>Input/Output functions</h6><div class="odoc-spec"><div class="spec value anchored" id="val-to_array"><a href="#val-to_array" class="anchor"></a><code><span><span class="keyword">val</span> to_array : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-save"><a href="#val-save" class="anchor"></a><code><span><span class="keyword">val</span> save : <span><span class="label">out</span>:string <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-load"><a href="#val-load" class="anchor"></a><code><span><span class="keyword">val</span> load : <span>string <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-save_npy"><a href="#val-save_npy" class="anchor"></a><code><span><span class="keyword">val</span> save_npy : <span><span class="label">out</span>:string <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-load_npy"><a href="#val-load_npy" class="anchor"></a><code><span><span class="keyword">val</span> load_npy : <span>string <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><h6 id="unary-mathematical-operations"><a href="#unary-mathematical-operations" class="anchor"></a>Unary mathematical operations</h6><div class="odoc-spec"><div class="spec value anchored" id="val-prod"><a href="#val-prod" class="anchor"></a><code><span><span class="keyword">val</span> prod : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-prod'"><a href="#val-prod'" class="anchor"></a><code><span><span class="keyword">val</span> prod' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mean"><a href="#val-mean" class="anchor"></a><code><span><span class="keyword">val</span> mean : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mean'"><a href="#val-mean'" class="anchor"></a><code><span><span class="keyword">val</span> mean' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-median'"><a href="#val-median'" class="anchor"></a><code><span><span class="keyword">val</span> median' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-median"><a href="#val-median" class="anchor"></a><code><span><span class="keyword">val</span> median : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-var"><a href="#val-var" class="anchor"></a><code><span><span class="keyword">val</span> var : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-var'"><a href="#val-var'" class="anchor"></a><code><span><span class="keyword">val</span> var' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-std"><a href="#val-std" class="anchor"></a><code><span><span class="keyword">val</span> std : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-std'"><a href="#val-std'" class="anchor"></a><code><span><span class="keyword">val</span> std' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sem"><a href="#val-sem" class="anchor"></a><code><span><span class="keyword">val</span> sem : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sem'"><a href="#val-sem'" class="anchor"></a><code><span><span class="keyword">val</span> sem' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-minmax"><a href="#val-minmax" class="anchor"></a><code><span><span class="keyword">val</span> minmax : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a> * <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-minmax'"><a href="#val-minmax'" class="anchor"></a><code><span><span class="keyword">val</span> minmax' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a> * <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min_i"><a href="#val-min_i" class="anchor"></a><code><span><span class="keyword">val</span> min_i : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a> * <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_i"><a href="#val-max_i" class="anchor"></a><code><span><span class="keyword">val</span> max_i : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a> * <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-minmax_i"><a href="#val-minmax_i" class="anchor"></a><code><span><span class="keyword">val</span> minmax_i : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>(<a href="#type-elt">elt</a> * <span>int array</span>)</span> * <span>(<a href="#type-elt">elt</a> * <span>int array</span>)</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-abs2"><a href="#val-abs2" class="anchor"></a><code><span><span class="keyword">val</span> abs2 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conj"><a href="#val-conj" class="anchor"></a><code><span><span class="keyword">val</span> conj : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reci"><a href="#val-reci" class="anchor"></a><code><span><span class="keyword">val</span> reci : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reci_tol"><a href="#val-reci_tol" class="anchor"></a><code><span><span class="keyword">val</span> reci_tol : <span><span class="optlabel">?tol</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cbrt"><a href="#val-cbrt" class="anchor"></a><code><span><span class="keyword">val</span> cbrt : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp2"><a href="#val-exp2" class="anchor"></a><code><span><span class="keyword">val</span> exp2 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp10"><a href="#val-exp10" class="anchor"></a><code><span><span class="keyword">val</span> exp10 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expm1"><a href="#val-expm1" class="anchor"></a><code><span><span class="keyword">val</span> expm1 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log1p"><a href="#val-log1p" class="anchor"></a><code><span><span class="keyword">val</span> log1p : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trunc"><a href="#val-trunc" class="anchor"></a><code><span><span class="keyword">val</span> trunc : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fix"><a href="#val-fix" class="anchor"></a><code><span><span class="keyword">val</span> fix : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-modf"><a href="#val-modf" class="anchor"></a><code><span><span class="keyword">val</span> modf : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a> * <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-l1norm"><a href="#val-l1norm" class="anchor"></a><code><span><span class="keyword">val</span> l1norm : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-l2norm"><a href="#val-l2norm" class="anchor"></a><code><span><span class="keyword">val</span> l2norm : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-l2norm_sqr"><a href="#val-l2norm_sqr" class="anchor"></a><code><span><span class="keyword">val</span> l2norm_sqr : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vecnorm"><a href="#val-vecnorm" class="anchor"></a><code><span><span class="keyword">val</span> vecnorm : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?p</span>:float <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-vecnorm'"><a href="#val-vecnorm'" class="anchor"></a><code><span><span class="keyword">val</span> vecnorm' : <span><span class="optlabel">?p</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cumsum"><a href="#val-cumsum" class="anchor"></a><code><span><span class="keyword">val</span> cumsum : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cumprod"><a href="#val-cumprod" class="anchor"></a><code><span><span class="keyword">val</span> cumprod : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cummin"><a href="#val-cummin" class="anchor"></a><code><span><span class="keyword">val</span> cummin : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cummax"><a href="#val-cummax" class="anchor"></a><code><span><span class="keyword">val</span> cummax : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-diff"><a href="#val-diff" class="anchor"></a><code><span><span class="keyword">val</span> diff : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?n</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-lgamma"><a href="#val-lgamma" class="anchor"></a><code><span><span class="keyword">val</span> lgamma : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><h6 id="binary-mathematical-operations"><a href="#binary-mathematical-operations" class="anchor"></a>Binary mathematical operations</h6><div class="odoc-spec"><div class="spec value anchored" id="val-min2"><a href="#val-min2" class="anchor"></a><code><span><span class="keyword">val</span> min2 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max2"><a href="#val-max2" class="anchor"></a><code><span><span class="keyword">val</span> max2 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ssqr'"><a href="#val-ssqr'" class="anchor"></a><code><span><span class="keyword">val</span> ssqr' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ssqr_diff'"><a href="#val-ssqr_diff'" class="anchor"></a><code><span><span class="keyword">val</span> ssqr_diff' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><h6 id="tensor-calculus"><a href="#tensor-calculus" class="anchor"></a>Tensor Calculus</h6><div class="odoc-spec"><div class="spec value anchored" id="val-contract1"><a href="#val-contract1" class="anchor"></a><code><span><span class="keyword">val</span> contract1 : <span><span><span>(int * int)</span> array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-contract2"><a href="#val-contract2" class="anchor"></a><code><span><span class="keyword">val</span> contract2 : <span><span><span>(int * int)</span> array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><h6 id="experimental-functions"><a href="#experimental-functions" class="anchor"></a>Experimental functions</h6><div class="odoc-spec"><div class="spec value anchored" id="val-slide"><a href="#val-slide" class="anchor"></a><code><span><span class="keyword">val</span> slide : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?ofs</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?step</span>:int <span class="arrow">-></span></span> <span><span class="label">window</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><h6 id="functions-of-in-place-modification"><a href="#functions-of-in-place-modification" class="anchor"></a>Functions of in-place modification</h6><div class="odoc-spec"><div class="spec value anchored" id="val-create_"><a href="#val-create_" class="anchor"></a><code><span><span class="keyword">val</span> create_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-uniform_"><a href="#val-uniform_" class="anchor"></a><code><span><span class="keyword">val</span> uniform_ : <span><span class="optlabel">?a</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?b</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-gaussian_"><a href="#val-gaussian_" class="anchor"></a><code><span><span class="keyword">val</span> gaussian_ : <span><span class="optlabel">?mu</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?sigma</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sequential_"><a href="#val-sequential_" class="anchor"></a><code><span><span class="keyword">val</span> sequential_ : <span><span class="optlabel">?a</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?step</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-bernoulli_"><a href="#val-bernoulli_" class="anchor"></a><code><span><span class="keyword">val</span> bernoulli_ : <span><span class="optlabel">?p</span>:float <span class="arrow">-></span></span> <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-zeros_"><a href="#val-zeros_" class="anchor"></a><code><span><span class="keyword">val</span> zeros_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ones_"><a href="#val-ones_" class="anchor"></a><code><span><span class="keyword">val</span> ones_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sort_"><a href="#val-sort_" class="anchor"></a><code><span><span class="keyword">val</span> sort_ : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-one_hot_"><a href="#val-one_hot_" class="anchor"></a><code><span><span class="keyword">val</span> one_hot_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_fancy_"><a href="#val-get_fancy_" class="anchor"></a><code><span><span class="keyword">val</span> get_fancy_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><a href="../../../owl-base/Owl_types/index.html#type-index">Owl_types.index</a> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_fancy_"><a href="#val-set_fancy_" class="anchor"></a><code><span><span class="keyword">val</span> set_fancy_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><a href="../../../owl-base/Owl_types/index.html#type-index">Owl_types.index</a> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-get_slice_"><a href="#val-get_slice_" class="anchor"></a><code><span><span class="keyword">val</span> get_slice_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><span>int list</span> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-set_slice_"><a href="#val-set_slice_" class="anchor"></a><code><span><span class="keyword">val</span> set_slice_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><span>int list</span> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reshape_"><a href="#val-reshape_" class="anchor"></a><code><span><span class="keyword">val</span> reshape_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reverse_"><a href="#val-reverse_" class="anchor"></a><code><span><span class="keyword">val</span> reverse_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_"><a href="#val-transpose_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?axis</span>:<span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-repeat_"><a href="#val-repeat_" class="anchor"></a><code><span><span class="keyword">val</span> repeat_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tile_"><a href="#val-tile_" class="anchor"></a><code><span><span class="keyword">val</span> tile_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pad_"><a href="#val-pad_" class="anchor"></a><code><span><span class="keyword">val</span> pad_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?v</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span><span>int list</span> list</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sum_"><a href="#val-sum_" class="anchor"></a><code><span><span class="keyword">val</span> sum_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="label">axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min_"><a href="#val-min_" class="anchor"></a><code><span><span class="keyword">val</span> min_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="label">axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_"><a href="#val-max_" class="anchor"></a><code><span><span class="keyword">val</span> max_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="label">axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_"><a href="#val-add_" class="anchor"></a><code><span><span class="keyword">val</span> add_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub_"><a href="#val-sub_" class="anchor"></a><code><span><span class="keyword">val</span> sub_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mul_"><a href="#val-mul_" class="anchor"></a><code><span><span class="keyword">val</span> mul_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-div_"><a href="#val-div_" class="anchor"></a><code><span><span class="keyword">val</span> div_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pow_"><a href="#val-pow_" class="anchor"></a><code><span><span class="keyword">val</span> pow_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atan2_"><a href="#val-atan2_" class="anchor"></a><code><span><span class="keyword">val</span> atan2_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hypot_"><a href="#val-hypot_" class="anchor"></a><code><span><span class="keyword">val</span> hypot_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fmod_"><a href="#val-fmod_" class="anchor"></a><code><span><span class="keyword">val</span> fmod_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-min2_"><a href="#val-min2_" class="anchor"></a><code><span><span class="keyword">val</span> min2_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max2_"><a href="#val-max2_" class="anchor"></a><code><span><span class="keyword">val</span> max2_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-add_scalar_"><a href="#val-add_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> add_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sub_scalar_"><a href="#val-sub_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> sub_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-mul_scalar_"><a href="#val-mul_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> mul_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-div_scalar_"><a href="#val-div_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> div_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-pow_scalar_"><a href="#val-pow_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> pow_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atan2_scalar_"><a href="#val-atan2_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> atan2_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fmod_scalar_"><a href="#val-fmod_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> fmod_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_add_"><a href="#val-scalar_add_" class="anchor"></a><code><span><span class="keyword">val</span> scalar_add_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_sub_"><a href="#val-scalar_sub_" class="anchor"></a><code><span><span class="keyword">val</span> scalar_sub_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_mul_"><a href="#val-scalar_mul_" class="anchor"></a><code><span><span class="keyword">val</span> scalar_mul_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_div_"><a href="#val-scalar_div_" class="anchor"></a><code><span><span class="keyword">val</span> scalar_div_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_pow_"><a href="#val-scalar_pow_" class="anchor"></a><code><span><span class="keyword">val</span> scalar_pow_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_atan2_"><a href="#val-scalar_atan2_" class="anchor"></a><code><span><span class="keyword">val</span> scalar_atan2_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_fmod_"><a href="#val-scalar_fmod_" class="anchor"></a><code><span><span class="keyword">val</span> scalar_fmod_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fma_"><a href="#val-fma_" class="anchor"></a><code><span><span class="keyword">val</span> fma_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clip_by_value_"><a href="#val-clip_by_value_" class="anchor"></a><code><span><span class="keyword">val</span> clip_by_value_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?amin</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?amax</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clip_by_l2norm_"><a href="#val-clip_by_l2norm_" class="anchor"></a><code><span><span class="keyword">val</span> clip_by_l2norm_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dot_"><a href="#val-dot_" class="anchor"></a><code><span><span class="keyword">val</span> dot_ :
<span><span class="optlabel">?transa</span>:bool <span class="arrow">-></span></span>
<span><span class="optlabel">?transb</span>:bool <span class="arrow">-></span></span>
<span><span class="optlabel">?alpha</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?beta</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span>
<span><span class="label">c</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conj_"><a href="#val-conj_" class="anchor"></a><code><span><span class="keyword">val</span> conj_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-abs_"><a href="#val-abs_" class="anchor"></a><code><span><span class="keyword">val</span> abs_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-neg_"><a href="#val-neg_" class="anchor"></a><code><span><span class="keyword">val</span> neg_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-reci_"><a href="#val-reci_" class="anchor"></a><code><span><span class="keyword">val</span> reci_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-signum_"><a href="#val-signum_" class="anchor"></a><code><span><span class="keyword">val</span> signum_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sqr_"><a href="#val-sqr_" class="anchor"></a><code><span><span class="keyword">val</span> sqr_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sqrt_"><a href="#val-sqrt_" class="anchor"></a><code><span><span class="keyword">val</span> sqrt_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cbrt_"><a href="#val-cbrt_" class="anchor"></a><code><span><span class="keyword">val</span> cbrt_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp_"><a href="#val-exp_" class="anchor"></a><code><span><span class="keyword">val</span> exp_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp2_"><a href="#val-exp2_" class="anchor"></a><code><span><span class="keyword">val</span> exp2_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-exp10_"><a href="#val-exp10_" class="anchor"></a><code><span><span class="keyword">val</span> exp10_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-expm1_"><a href="#val-expm1_" class="anchor"></a><code><span><span class="keyword">val</span> expm1_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log_"><a href="#val-log_" class="anchor"></a><code><span><span class="keyword">val</span> log_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log2_"><a href="#val-log2_" class="anchor"></a><code><span><span class="keyword">val</span> log2_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log10_"><a href="#val-log10_" class="anchor"></a><code><span><span class="keyword">val</span> log10_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log1p_"><a href="#val-log1p_" class="anchor"></a><code><span><span class="keyword">val</span> log1p_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sin_"><a href="#val-sin_" class="anchor"></a><code><span><span class="keyword">val</span> sin_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cos_"><a href="#val-cos_" class="anchor"></a><code><span><span class="keyword">val</span> cos_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tan_"><a href="#val-tan_" class="anchor"></a><code><span><span class="keyword">val</span> tan_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-asin_"><a href="#val-asin_" class="anchor"></a><code><span><span class="keyword">val</span> asin_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-acos_"><a href="#val-acos_" class="anchor"></a><code><span><span class="keyword">val</span> acos_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atan_"><a href="#val-atan_" class="anchor"></a><code><span><span class="keyword">val</span> atan_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sinh_"><a href="#val-sinh_" class="anchor"></a><code><span><span class="keyword">val</span> sinh_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cosh_"><a href="#val-cosh_" class="anchor"></a><code><span><span class="keyword">val</span> cosh_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-tanh_"><a href="#val-tanh_" class="anchor"></a><code><span><span class="keyword">val</span> tanh_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-asinh_"><a href="#val-asinh_" class="anchor"></a><code><span><span class="keyword">val</span> asinh_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-acosh_"><a href="#val-acosh_" class="anchor"></a><code><span><span class="keyword">val</span> acosh_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atanh_"><a href="#val-atanh_" class="anchor"></a><code><span><span class="keyword">val</span> atanh_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-floor_"><a href="#val-floor_" class="anchor"></a><code><span><span class="keyword">val</span> floor_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-ceil_"><a href="#val-ceil_" class="anchor"></a><code><span><span class="keyword">val</span> ceil_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-round_"><a href="#val-round_" class="anchor"></a><code><span><span class="keyword">val</span> round_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trunc_"><a href="#val-trunc_" class="anchor"></a><code><span><span class="keyword">val</span> trunc_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fix_"><a href="#val-fix_" class="anchor"></a><code><span><span class="keyword">val</span> fix_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-erf_"><a href="#val-erf_" class="anchor"></a><code><span><span class="keyword">val</span> erf_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-erfc_"><a href="#val-erfc_" class="anchor"></a><code><span><span class="keyword">val</span> erfc_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-relu_"><a href="#val-relu_" class="anchor"></a><code><span><span class="keyword">val</span> relu_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-softplus_"><a href="#val-softplus_" class="anchor"></a><code><span><span class="keyword">val</span> softplus_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-softsign_"><a href="#val-softsign_" class="anchor"></a><code><span><span class="keyword">val</span> softsign_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sigmoid_"><a href="#val-sigmoid_" class="anchor"></a><code><span><span class="keyword">val</span> sigmoid_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-softmax_"><a href="#val-softmax_" class="anchor"></a><code><span><span class="keyword">val</span> softmax_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cumsum_"><a href="#val-cumsum_" class="anchor"></a><code><span><span class="keyword">val</span> cumsum_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cumprod_"><a href="#val-cumprod_" class="anchor"></a><code><span><span class="keyword">val</span> cumprod_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cummin_"><a href="#val-cummin_" class="anchor"></a><code><span><span class="keyword">val</span> cummin_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cummax_"><a href="#val-cummax_" class="anchor"></a><code><span><span class="keyword">val</span> cummax_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dropout_"><a href="#val-dropout_" class="anchor"></a><code><span><span class="keyword">val</span> dropout_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="optlabel">?rate</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_equal_"><a href="#val-elt_equal_" class="anchor"></a><code><span><span class="keyword">val</span> elt_equal_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_not_equal_"><a href="#val-elt_not_equal_" class="anchor"></a><code><span><span class="keyword">val</span> elt_not_equal_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less_"><a href="#val-elt_less_" class="anchor"></a><code><span><span class="keyword">val</span> elt_less_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater_"><a href="#val-elt_greater_" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less_equal_"><a href="#val-elt_less_equal_" class="anchor"></a><code><span><span class="keyword">val</span> elt_less_equal_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater_equal_"><a href="#val-elt_greater_equal_" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater_equal_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_equal_scalar_"><a href="#val-elt_equal_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> elt_equal_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_not_equal_scalar_"><a href="#val-elt_not_equal_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> elt_not_equal_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less_scalar_"><a href="#val-elt_less_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> elt_less_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater_scalar_"><a href="#val-elt_greater_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_less_equal_scalar_"><a href="#val-elt_less_equal_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> elt_less_equal_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_greater_equal_scalar_"><a href="#val-elt_greater_equal_scalar_" class="anchor"></a><code><span><span class="keyword">val</span> elt_greater_equal_scalar_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> unit</span></code></div><div class="spec-doc"><p>Matrix functions</p></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-col"><a href="#val-col" class="anchor"></a><code><span><span class="keyword">val</span> col : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cols"><a href="#val-cols" class="anchor"></a><code><span><span class="keyword">val</span> cols : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-to_arrays"><a href="#val-to_arrays" class="anchor"></a><code><span><span class="keyword">val</span> to_arrays : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span><a href="#type-elt">elt</a> array</span> array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-draw_rows"><a href="#val-draw_rows" class="anchor"></a><code><span><span class="keyword">val</span> draw_rows : <span><span class="optlabel">?replacement</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a> * <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-draw_cols"><a href="#val-draw_cols" class="anchor"></a><code><span><span class="keyword">val</span> draw_cols : <span><span class="optlabel">?replacement</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <a href="#type-arr">arr</a> * <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-draw_rows2"><a href="#val-draw_rows2" class="anchor"></a><code><span><span class="keyword">val</span> draw_rows2 :
<span><span class="optlabel">?replacement</span>:bool <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span>int <span class="arrow">-></span></span>
<a href="#type-arr">arr</a> * <a href="#type-arr">arr</a> * <span>int array</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-draw_cols2"><a href="#val-draw_cols2" class="anchor"></a><code><span><span class="keyword">val</span> draw_cols2 :
<span><span class="optlabel">?replacement</span>:bool <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span>int <span class="arrow">-></span></span>
<a href="#type-arr">arr</a> * <a href="#type-arr">arr</a> * <span>int array</span></span></code></div></div></details></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../Owl_dense_ndarray_intf/module-type-Real/index.html">Owl_dense_ndarray_intf.Real</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../Owl_dense_ndarray_intf/module-type-Real/index.html#type-elt">elt</a> := <a href="#type-elt">elt</a></span> <span class="keyword">and</span> <span><span class="keyword">type</span> <a href="../../Owl_dense_ndarray_intf/module-type-Real/index.html#type-arr">arr</a> := <a href="#type-arr">arr</a></span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-Real/index.html">Owl_base_dense_ndarray_intf.Real</a>
<span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-Real/index.html#type-elt">elt</a> := <a href="#type-elt">elt</a></span>
<span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-Real/index.html#type-arr">arr</a> := <a href="#type-arr">arr</a></span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-sum_slices"><a href="#val-sum_slices" class="anchor"></a><code><span><span class="keyword">val</span> sum_slices : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-signum"><a href="#val-signum" class="anchor"></a><code><span><span class="keyword">val</span> signum : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-relu"><a href="#val-relu" class="anchor"></a><code><span><span class="keyword">val</span> relu : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dawsn"><a href="#val-dawsn" class="anchor"></a><code><span><span class="keyword">val</span> dawsn : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-l1norm'"><a href="#val-l1norm'" class="anchor"></a><code><span><span class="keyword">val</span> l1norm' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-l2norm'"><a href="#val-l2norm'" class="anchor"></a><code><span><span class="keyword">val</span> l2norm' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-l2norm_sqr'"><a href="#val-l2norm_sqr'" class="anchor"></a><code><span><span class="keyword">val</span> l2norm_sqr' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clip_by_value"><a href="#val-clip_by_value" class="anchor"></a><code><span><span class="keyword">val</span> clip_by_value : <span><span class="optlabel">?amin</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="optlabel">?amax</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-clip_by_l2norm"><a href="#val-clip_by_l2norm" class="anchor"></a><code><span><span class="keyword">val</span> clip_by_l2norm : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atan2"><a href="#val-atan2" class="anchor"></a><code><span><span class="keyword">val</span> atan2 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-approx_equal"><a href="#val-approx_equal" class="anchor"></a><code><span><span class="keyword">val</span> approx_equal : <span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-approx_equal_scalar"><a href="#val-approx_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> approx_equal_scalar : <span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>float <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-approx_elt_equal"><a href="#val-approx_elt_equal" class="anchor"></a><code><span><span class="keyword">val</span> approx_elt_equal : <span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-approx_elt_equal_scalar"><a href="#val-approx_elt_equal_scalar" class="anchor"></a><code><span><span class="keyword">val</span> approx_elt_equal_scalar : <span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span>float <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dot"><a href="#val-dot" class="anchor"></a><code><span><span class="keyword">val</span> dot : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-trace"><a href="#val-trace" class="anchor"></a><code><span><span class="keyword">val</span> trace : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><h6 id="helper-functions"><a href="#helper-functions" class="anchor"></a>Helper functions</h6><div class="odoc-spec"><div class="spec value anchored" id="val-float_to_elt"><a href="#val-float_to_elt" class="anchor"></a><code><span><span class="keyword">val</span> float_to_elt : <span>float <span class="arrow">-></span></span> <a href="#type-elt">elt</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elt_to_float"><a href="#val-elt_to_float" class="anchor"></a><code><span><span class="keyword">val</span> elt_to_float : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> float</span></code></div></div></details></div><h6 id="real-operations"><a href="#real-operations" class="anchor"></a>Real operations</h6><div class="odoc-spec"><div class="spec value anchored" id="val-i0"><a href="#val-i0" class="anchor"></a><code><span><span class="keyword">val</span> i0 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-i0e"><a href="#val-i0e" class="anchor"></a><code><span><span class="keyword">val</span> i0e : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-i1"><a href="#val-i1" class="anchor"></a><code><span><span class="keyword">val</span> i1 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-i1e"><a href="#val-i1e" class="anchor"></a><code><span><span class="keyword">val</span> i1e : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iv"><a href="#val-iv" class="anchor"></a><code><span><span class="keyword">val</span> iv : <span><span class="label">v</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_iv"><a href="#val-scalar_iv" class="anchor"></a><code><span><span class="keyword">val</span> scalar_iv : <span><span class="label">v</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-iv_scalar"><a href="#val-iv_scalar" class="anchor"></a><code><span><span class="keyword">val</span> iv_scalar : <span><span class="label">v</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-j0"><a href="#val-j0" class="anchor"></a><code><span><span class="keyword">val</span> j0 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-j1"><a href="#val-j1" class="anchor"></a><code><span><span class="keyword">val</span> j1 : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-jv"><a href="#val-jv" class="anchor"></a><code><span><span class="keyword">val</span> jv : <span><span class="label">v</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_jv"><a href="#val-scalar_jv" class="anchor"></a><code><span><span class="keyword">val</span> scalar_jv : <span><span class="label">v</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-jv_scalar"><a href="#val-jv_scalar" class="anchor"></a><code><span><span class="keyword">val</span> jv_scalar : <span><span class="label">v</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-erf"><a href="#val-erf" class="anchor"></a><code><span><span class="keyword">val</span> erf : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-erfc"><a href="#val-erfc" class="anchor"></a><code><span><span class="keyword">val</span> erfc : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-logistic"><a href="#val-logistic" class="anchor"></a><code><span><span class="keyword">val</span> logistic : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-elu"><a href="#val-elu" class="anchor"></a><code><span><span class="keyword">val</span> elu : <span><span class="optlabel">?alpha</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-leaky_relu"><a href="#val-leaky_relu" class="anchor"></a><code><span><span class="keyword">val</span> leaky_relu : <span><span class="optlabel">?alpha</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-softplus"><a href="#val-softplus" class="anchor"></a><code><span><span class="keyword">val</span> softplus : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-softsign"><a href="#val-softsign" class="anchor"></a><code><span><span class="keyword">val</span> softsign : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-softmax"><a href="#val-softmax" class="anchor"></a><code><span><span class="keyword">val</span> softmax : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-sigmoid"><a href="#val-sigmoid" class="anchor"></a><code><span><span class="keyword">val</span> sigmoid : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log_sum_exp'"><a href="#val-log_sum_exp'" class="anchor"></a><code><span><span class="keyword">val</span> log_sum_exp' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> float</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-log_sum_exp"><a href="#val-log_sum_exp" class="anchor"></a><code><span><span class="keyword">val</span> log_sum_exp : <span><span class="optlabel">?axis</span>:int <span class="arrow">-></span></span> <span><span class="optlabel">?keep_dims</span>:bool <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_atan2"><a href="#val-scalar_atan2" class="anchor"></a><code><span><span class="keyword">val</span> scalar_atan2 : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-atan2_scalar"><a href="#val-atan2_scalar" class="anchor"></a><code><span><span class="keyword">val</span> atan2_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-hypot"><a href="#val-hypot" class="anchor"></a><code><span><span class="keyword">val</span> hypot : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fmod"><a href="#val-fmod" class="anchor"></a><code><span><span class="keyword">val</span> fmod : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fmod_scalar"><a href="#val-fmod_scalar" class="anchor"></a><code><span><span class="keyword">val</span> fmod_scalar : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-scalar_fmod"><a href="#val-scalar_fmod" class="anchor"></a><code><span><span class="keyword">val</span> scalar_fmod : <span><a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-cross_entropy'"><a href="#val-cross_entropy'" class="anchor"></a><code><span><span class="keyword">val</span> cross_entropy' : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> float</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-fused_adagrad_"><a href="#val-fused_adagrad_" class="anchor"></a><code><span><span class="keyword">val</span> fused_adagrad_ : <span><span class="optlabel">?out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span class="label">rate</span>:float <span class="arrow">-></span></span> <span><span class="label">eps</span>:float <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-poisson"><a href="#val-poisson" class="anchor"></a><code><span><span class="keyword">val</span> poisson : <span><span class="label">mu</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-poisson_"><a href="#val-poisson_" class="anchor"></a><code><span><span class="keyword">val</span> poisson_ : <span><span class="label">mu</span>:<a href="#type-elt">elt</a> <span class="arrow">-></span></span> <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div></details></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../Owl_dense_ndarray_intf/module-type-NN/index.html">Owl_dense_ndarray_intf.NN</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../Owl_dense_ndarray_intf/module-type-NN/index.html#type-arr">arr</a> := <a href="#type-arr">arr</a></span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-NN/index.html">Owl_base_dense_ndarray_intf.NN</a> <span class="keyword">with</span> <span><span class="keyword">type</span> <a href="../../../owl-base/Owl_base_dense_ndarray_intf/module-type-NN/index.html#type-arr">arr</a> := <a href="#type-arr">arr</a></span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-conv1d"><a href="#val-conv1d" class="anchor"></a><code><span><span class="keyword">val</span> conv1d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv2d"><a href="#val-conv2d" class="anchor"></a><code><span><span class="keyword">val</span> conv2d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv3d"><a href="#val-conv3d" class="anchor"></a><code><span><span class="keyword">val</span> conv3d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv1d"><a href="#val-dilated_conv1d" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv1d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv2d"><a href="#val-dilated_conv2d" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv2d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv3d"><a href="#val-dilated_conv3d" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv3d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv1d"><a href="#val-transpose_conv1d" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv1d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv2d"><a href="#val-transpose_conv2d" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv2d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv3d"><a href="#val-transpose_conv3d" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv3d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool1d"><a href="#val-max_pool1d" class="anchor"></a><code><span><span class="keyword">val</span> max_pool1d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool2d"><a href="#val-max_pool2d" class="anchor"></a><code><span><span class="keyword">val</span> max_pool2d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool3d"><a href="#val-max_pool3d" class="anchor"></a><code><span><span class="keyword">val</span> max_pool3d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool1d"><a href="#val-avg_pool1d" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool1d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool2d"><a href="#val-avg_pool2d" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool2d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool3d"><a href="#val-avg_pool3d" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool3d :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-upsampling2d"><a href="#val-upsampling2d" class="anchor"></a><code><span><span class="keyword">val</span> upsampling2d : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv1d_backward_input"><a href="#val-conv1d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> conv1d_backward_input : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv1d_backward_kernel"><a href="#val-conv1d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> conv1d_backward_kernel : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv2d_backward_input"><a href="#val-conv2d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> conv2d_backward_input : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv2d_backward_kernel"><a href="#val-conv2d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> conv2d_backward_kernel : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv3d_backward_input"><a href="#val-conv3d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> conv3d_backward_input : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv3d_backward_kernel"><a href="#val-conv3d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> conv3d_backward_kernel : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv1d_backward_input"><a href="#val-dilated_conv1d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv1d_backward_input :
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv1d_backward_kernel"><a href="#val-dilated_conv1d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv1d_backward_kernel :
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv2d_backward_input"><a href="#val-dilated_conv2d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv2d_backward_input :
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv2d_backward_kernel"><a href="#val-dilated_conv2d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv2d_backward_kernel :
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv3d_backward_input"><a href="#val-dilated_conv3d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv3d_backward_input :
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv3d_backward_kernel"><a href="#val-dilated_conv3d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv3d_backward_kernel :
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv1d_backward_input"><a href="#val-transpose_conv1d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv1d_backward_input : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv1d_backward_kernel"><a href="#val-transpose_conv1d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv1d_backward_kernel : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv2d_backward_input"><a href="#val-transpose_conv2d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv2d_backward_input : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv2d_backward_kernel"><a href="#val-transpose_conv2d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv2d_backward_kernel : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv3d_backward_input"><a href="#val-transpose_conv3d_backward_input" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv3d_backward_input : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv3d_backward_kernel"><a href="#val-transpose_conv3d_backward_kernel" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv3d_backward_kernel : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool1d_backward"><a href="#val-max_pool1d_backward" class="anchor"></a><code><span><span class="keyword">val</span> max_pool1d_backward :
<span><a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool2d_backward"><a href="#val-max_pool2d_backward" class="anchor"></a><code><span><span class="keyword">val</span> max_pool2d_backward :
<span><a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool3d_backward"><a href="#val-max_pool3d_backward" class="anchor"></a><code><span><span class="keyword">val</span> max_pool3d_backward :
<span><a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool1d_backward"><a href="#val-avg_pool1d_backward" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool1d_backward :
<span><a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool2d_backward"><a href="#val-avg_pool2d_backward" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool2d_backward :
<span><a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool3d_backward"><a href="#val-avg_pool3d_backward" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool3d_backward :
<span><a href="../../../owl-base/Owl_types_common/index.html#type-padding">Owl_types_common.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-upsampling2d_backward"><a href="#val-upsampling2d_backward" class="anchor"></a><code><span><span class="keyword">val</span> upsampling2d_backward : <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <a href="#type-arr">arr</a></span></code></div></div></details></div><h6 id="neural-network-related-functions"><a href="#neural-network-related-functions" class="anchor"></a>Neural network related functions</h6><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool2d_argmax"><a href="#val-max_pool2d_argmax" class="anchor"></a><code><span><span class="keyword">val</span> max_pool2d_argmax :
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<a href="#type-arr">arr</a>
* <span><span>(int64, <span class="xref-unresolved">Stdlib</span>.Bigarray.int64_elt, <span class="xref-unresolved">Stdlib</span>.Bigarray.c_layout)</span>
<span class="xref-unresolved">Stdlib</span>.Bigarray.Genarray.t</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv1d_"><a href="#val-conv1d_" class="anchor"></a><code><span><span class="keyword">val</span> conv1d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv2d_"><a href="#val-conv2d_" class="anchor"></a><code><span><span class="keyword">val</span> conv2d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv3d_"><a href="#val-conv3d_" class="anchor"></a><code><span><span class="keyword">val</span> conv3d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv1d_"><a href="#val-dilated_conv1d_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv1d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv2d_"><a href="#val-dilated_conv2d_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv2d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv3d_"><a href="#val-dilated_conv3d_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv3d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv1d_"><a href="#val-transpose_conv1d_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv1d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv2d_"><a href="#val-transpose_conv2d_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv2d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv3d_"><a href="#val-transpose_conv3d_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv3d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool1d_"><a href="#val-max_pool1d_" class="anchor"></a><code><span><span class="keyword">val</span> max_pool1d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool2d_"><a href="#val-max_pool2d_" class="anchor"></a><code><span><span class="keyword">val</span> max_pool2d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool3d_"><a href="#val-max_pool3d_" class="anchor"></a><code><span><span class="keyword">val</span> max_pool3d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool1d_"><a href="#val-avg_pool1d_" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool1d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool2d_"><a href="#val-avg_pool2d_" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool2d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool3d_"><a href="#val-avg_pool3d_" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool3d_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span class="optlabel">?padding</span>:<a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-upsampling2d_"><a href="#val-upsampling2d_" class="anchor"></a><code><span><span class="keyword">val</span> upsampling2d_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv1d_backward_input_"><a href="#val-conv1d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> conv1d_backward_input_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv1d_backward_kernel_"><a href="#val-conv1d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> conv1d_backward_kernel_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv2d_backward_input_"><a href="#val-conv2d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> conv2d_backward_input_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv2d_backward_kernel_"><a href="#val-conv2d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> conv2d_backward_kernel_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv3d_backward_input_"><a href="#val-conv3d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> conv3d_backward_input_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-conv3d_backward_kernel_"><a href="#val-conv3d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> conv3d_backward_kernel_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv1d_backward_input_"><a href="#val-dilated_conv1d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv1d_backward_input_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv1d_backward_kernel_"><a href="#val-dilated_conv1d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv1d_backward_kernel_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv2d_backward_input_"><a href="#val-dilated_conv2d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv2d_backward_input_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv2d_backward_kernel_"><a href="#val-dilated_conv2d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv2d_backward_kernel_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv3d_backward_input_"><a href="#val-dilated_conv3d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv3d_backward_input_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-dilated_conv3d_backward_kernel_"><a href="#val-dilated_conv3d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> dilated_conv3d_backward_kernel_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv1d_backward_input_"><a href="#val-transpose_conv1d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv1d_backward_input_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv1d_backward_kernel_"><a href="#val-transpose_conv1d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv1d_backward_kernel_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv2d_backward_input_"><a href="#val-transpose_conv2d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv2d_backward_input_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv2d_backward_kernel_"><a href="#val-transpose_conv2d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv2d_backward_kernel_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv3d_backward_input_"><a href="#val-transpose_conv3d_backward_input_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv3d_backward_input_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-transpose_conv3d_backward_kernel_"><a href="#val-transpose_conv3d_backward_kernel_" class="anchor"></a><code><span><span class="keyword">val</span> transpose_conv3d_backward_kernel_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool1d_backward_"><a href="#val-max_pool1d_backward_" class="anchor"></a><code><span><span class="keyword">val</span> max_pool1d_backward_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool2d_backward_"><a href="#val-max_pool2d_backward_" class="anchor"></a><code><span><span class="keyword">val</span> max_pool2d_backward_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-max_pool3d_backward_"><a href="#val-max_pool3d_backward_" class="anchor"></a><code><span><span class="keyword">val</span> max_pool3d_backward_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool1d_backward_"><a href="#val-avg_pool1d_backward_" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool1d_backward_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool2d_backward_"><a href="#val-avg_pool2d_backward_" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool2d_backward_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-avg_pool3d_backward_"><a href="#val-avg_pool3d_backward_" class="anchor"></a><code><span><span class="keyword">val</span> avg_pool3d_backward_ :
<span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><a href="../../../owl-base/Owl_types/index.html#type-padding">Owl_types.padding</a> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><a href="#type-arr">arr</a> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-upsampling2d_backward_"><a href="#val-upsampling2d_backward_" class="anchor"></a><code><span><span class="keyword">val</span> upsampling2d_backward_ : <span><span class="label">out</span>:<a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span><a href="#type-arr">arr</a> <span class="arrow">-></span></span> unit</span></code></div></div></details></div></details></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">module</span> <span class="keyword">type</span> <span class="keyword">of</span> <span class="keyword">struct</span> <span class="keyword">include</span> <a href="../../Owl_dense_ndarray/Operator/index.html">Owl_dense_ndarray.Operator</a> <span class="keyword">end</span></span></code></summary><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-(+)"><a href="#val-(+)" class="anchor"></a><code><span><span class="keyword">val</span> (+) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(-)"><a href="#val-(-)" class="anchor"></a><code><span><span class="keyword">val</span> (-) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(*)"><a href="#val-(*)" class="anchor"></a><code><span><span class="keyword">val</span> (*) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(/)"><a href="#val-(/)" class="anchor"></a><code><span><span class="keyword">val</span> (/) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(+$)"><a href="#val-(+$)" class="anchor"></a><code><span><span class="keyword">val</span> (+$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(-$)"><a href="#val-(-$)" class="anchor"></a><code><span><span class="keyword">val</span> (-$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(*$)"><a href="#val-(*$)" class="anchor"></a><code><span><span class="keyword">val</span> (*$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(/$)"><a href="#val-(/$)" class="anchor"></a><code><span><span class="keyword">val</span> (/$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-($+)"><a href="#val-($+)" class="anchor"></a><code><span><span class="keyword">val</span> ($+) :
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-($-)"><a href="#val-($-)" class="anchor"></a><code><span><span class="keyword">val</span> ($-) :
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-($*)"><a href="#val-($*)" class="anchor"></a><code><span><span class="keyword">val</span> ($*) :
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-($/)"><a href="#val-($/)" class="anchor"></a><code><span><span class="keyword">val</span> ($/) :
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=)"><a href="#val-(=)" class="anchor"></a><code><span><span class="keyword">val</span> (=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(!=)"><a href="#val-(!=)" class="anchor"></a><code><span><span class="keyword">val</span> (!=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<>)"><a href="#val-(<>)" class="anchor"></a><code><span><span class="keyword">val</span> (<>) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>)"><a href="#val-(>)" class="anchor"></a><code><span><span class="keyword">val</span> (>) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<)"><a href="#val-(<)" class="anchor"></a><code><span><span class="keyword">val</span> (<) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>=)"><a href="#val-(>=)" class="anchor"></a><code><span><span class="keyword">val</span> (>=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<=)"><a href="#val-(<=)" class="anchor"></a><code><span><span class="keyword">val</span> (<=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div></details></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-(=$)"><a href="#val-(=$)" class="anchor"></a><code><span><span class="keyword">val</span> (=$) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(!=$)"><a href="#val-(!=$)" class="anchor"></a><code><span><span class="keyword">val</span> (!=$) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<>$)"><a href="#val-(<>$)" class="anchor"></a><code><span><span class="keyword">val</span> (<>$) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<$)"><a href="#val-(<$)" class="anchor"></a><code><span><span class="keyword">val</span> (<$) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>$)"><a href="#val-(>$)" class="anchor"></a><code><span><span class="keyword">val</span> (>$) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<=$)"><a href="#val-(<=$)" class="anchor"></a><code><span><span class="keyword">val</span> (<=$) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>=$)"><a href="#val-(>=$)" class="anchor"></a><code><span><span class="keyword">val</span> (>=$) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=.)"><a href="#val-(=.)" class="anchor"></a><code><span><span class="keyword">val</span> (=.) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(!=.)"><a href="#val-(!=.)" class="anchor"></a><code><span><span class="keyword">val</span> (!=.) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<>.)"><a href="#val-(<>.)" class="anchor"></a><code><span><span class="keyword">val</span> (<>.) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<.)"><a href="#val-(<.)" class="anchor"></a><code><span><span class="keyword">val</span> (<.) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>.)"><a href="#val-(>.)" class="anchor"></a><code><span><span class="keyword">val</span> (>.) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<=.)"><a href="#val-(<=.)" class="anchor"></a><code><span><span class="keyword">val</span> (<=.) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>=.)"><a href="#val-(>=.)" class="anchor"></a><code><span><span class="keyword">val</span> (>=.) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=.$)"><a href="#val-(=.$)" class="anchor"></a><code><span><span class="keyword">val</span> (=.$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(!=.$)"><a href="#val-(!=.$)" class="anchor"></a><code><span><span class="keyword">val</span> (!=.$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<>.$)"><a href="#val-(<>.$)" class="anchor"></a><code><span><span class="keyword">val</span> (<>.$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<.$)"><a href="#val-(<.$)" class="anchor"></a><code><span><span class="keyword">val</span> (<.$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>.$)"><a href="#val-(>.$)" class="anchor"></a><code><span><span class="keyword">val</span> (>.$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(<=.$)"><a href="#val-(<=.$)" class="anchor"></a><code><span><span class="keyword">val</span> (<=.$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(>=.$)"><a href="#val-(>=.$)" class="anchor"></a><code><span><span class="keyword">val</span> (>=.$) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=~)"><a href="#val-(=~)" class="anchor"></a><code><span><span class="keyword">val</span> (=~) :
<span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=~$)"><a href="#val-(=~$)" class="anchor"></a><code><span><span class="keyword">val</span> (=~$) : <span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span> <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> bool</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=~.)"><a href="#val-(=~.)" class="anchor"></a><code><span><span class="keyword">val</span> (=~.) :
<span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(=~.$)"><a href="#val-(=~.$)" class="anchor"></a><code><span><span class="keyword">val</span> (=~.$) :
<span><span class="optlabel">?eps</span>:float <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(%)"><a href="#val-(%)" class="anchor"></a><code><span><span class="keyword">val</span> (%) :
<span><span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(%$)"><a href="#val-(%$)" class="anchor"></a><code><span><span class="keyword">val</span> (%$) :
<span><span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span>float <span class="arrow">-></span></span>
<span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(**)"><a href="#val-(**)" class="anchor"></a><code><span><span class="keyword">val</span> (**) :
<span><span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-($**)"><a href="#val-($**)" class="anchor"></a><code><span><span class="keyword">val</span> ($**) :
<span>float <span class="arrow">-></span></span>
<span><span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(**$)"><a href="#val-(**$)" class="anchor"></a><code><span><span class="keyword">val</span> (**$) :
<span><span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span>float <span class="arrow">-></span></span>
<span><span>(float, <span class="type-var">'a</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(+=)"><a href="#val-(+=)" class="anchor"></a><code><span><span class="keyword">val</span> (+=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(-=)"><a href="#val-(-=)" class="anchor"></a><code><span><span class="keyword">val</span> (-=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(*=)"><a href="#val-(*=)" class="anchor"></a><code><span><span class="keyword">val</span> (*=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(/=)"><a href="#val-(/=)" class="anchor"></a><code><span><span class="keyword">val</span> (/=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(+$=)"><a href="#val-(+$=)" class="anchor"></a><code><span><span class="keyword">val</span> (+$=) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(-$=)"><a href="#val-(-$=)" class="anchor"></a><code><span><span class="keyword">val</span> (-$=) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(*$=)"><a href="#val-(*$=)" class="anchor"></a><code><span><span class="keyword">val</span> (*$=) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(/$=)"><a href="#val-(/$=)" class="anchor"></a><code><span><span class="keyword">val</span> (/$=) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(@=)"><a href="#val-(@=)" class="anchor"></a><code><span><span class="keyword">val</span> (@=) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(@||)"><a href="#val-(@||)" class="anchor"></a><code><span><span class="keyword">val</span> (@||) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.!{;..})"><a href="#val-(.!{;..})" class="anchor"></a><code><span><span class="keyword">val</span> (.!{;..}) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><a href="../../../owl-base/Owl_types/index.html#type-index">Owl_types.index</a> array</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.!{;..}<-)"><a href="#val-(.!{;..}<-)" class="anchor"></a><code><span><span class="keyword">val</span> (.!{;..}<-) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><a href="../../../owl-base/Owl_types/index.html#type-index">Owl_types.index</a> array</span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.${})"><a href="#val-(.${})" class="anchor"></a><code><span><span class="keyword">val</span> (.${}) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>int list</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.${;..})"><a href="#val-(.${;..})" class="anchor"></a><code><span><span class="keyword">val</span> (.${;..}) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>int list</span> array</span> <span class="arrow">-></span></span>
<span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.${}<-)"><a href="#val-(.${}<-)" class="anchor"></a><code><span><span class="keyword">val</span> (.${}<-) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>int list</span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.${;..}<-)"><a href="#val-(.${;..}<-)" class="anchor"></a><code><span><span class="keyword">val</span> (.${;..}<-) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span><span>int list</span> array</span> <span class="arrow">-></span></span>
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
unit</span></code></div></div></details></div><div class="odoc-include"><details open="open"><summary class="spec include"><code><span><span class="keyword">include</span> <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></summary><div class="odoc-spec"><div class="spec value anchored" id="val-(.%{})"><a href="#val-(.%{})" class="anchor"></a><code><span><span class="keyword">val</span> (.%{}) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.%{;..})"><a href="#val-(.%{;..})" class="anchor"></a><code><span><span class="keyword">val</span> (.%{;..}) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span><span>int array</span> <span class="arrow">-></span></span> <span class="type-var">'a</span></span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.%{}<-)"><a href="#val-(.%{}<-)" class="anchor"></a><code><span><span class="keyword">val</span> (.%{}<-) : <span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span> <span>int <span class="arrow">-></span></span> <span><span class="type-var">'a</span> <span class="arrow">-></span></span> unit</span></code></div></div><div class="odoc-spec"><div class="spec value anchored" id="val-(.%{;..}<-)"><a href="#val-(.%{;..}<-)" class="anchor"></a><code><span><span class="keyword">val</span> (.%{;..}<-) :
<span><span><span>(<span class="type-var">'a</span>, <span class="type-var">'b</span>)</span> <a href="../../Owl_dense_ndarray_generic/index.html#type-t">Owl_dense_ndarray_generic.t</a></span> <span class="arrow">-></span></span>
<span><span>int array</span> <span class="arrow">-></span></span>
<span><span class="type-var">'a</span> <span class="arrow">-></span></span>
unit</span></code></div></div></details></div></details></div><div class="odoc-spec"><div class="spec value anchored" id="val-mpow"><a href="#val-mpow" class="anchor"></a><code><span><span class="keyword">val</span> mpow : <span><a href="../../Owl_linalg_s/index.html#type-mat">Owl_linalg_s.mat</a> <span class="arrow">-></span></span> <span>float <span class="arrow">-></span></span> <a href="../../Owl_linalg_s/index.html#type-mat">Owl_linalg_s.mat</a></span></code></div></div></details></div><div class="odoc-spec"><div class="spec module anchored" id="module-Scalar"><a href="#module-Scalar" class="anchor"></a><code><span><span class="keyword">module</span> Scalar</span><span> = <a href="../../Owl_maths/index.html">Owl_maths</a></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Mat"><a href="#module-Mat" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Mat/index.html">Mat</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div><div class="odoc-spec"><div class="spec module anchored" id="module-Linalg"><a href="#module-Linalg" class="anchor"></a><code><span><span class="keyword">module</span> <a href="Linalg/index.html">Linalg</a></span><span> : <span class="keyword">sig</span> ... <span class="keyword">end</span></span></code></div></div></div></body></html>
```
|
Mystrocnemis fossulata is a species of beetle in the family Cerambycidae. It was described by Stephan von Breuning in 1956.
References
Saperdini
Beetles described in 1956
|
Daniel Williams-Hashemi (born 26 November 1994), better known by his stage name DanimaL is an English rapper from Sheffield, England, influenced by the boombap sound and conscious style hiphop. Described as a "high-viz clad mentalist" by UKHH, DanimaL has released two EP's and numerous singles. DanimaL achieved notoriety after releasing his somewhat controversial single "Adderall". Consequently, DanimaL signed to Sheffield-based Message of a Nation Records. He has featured on various well-known British hip hop YouTube channels including, but not limited to, GlobalFaction, JDZMedia, Ukhh, P110 Media and Northside Media TV. In 2019, he made a radio appearance on Itch FM which ranked 29th in the global old-school hip hop chart. DanimaL is vocal about his struggles with mental health and the bullying he received growing up. In an interview with the Star newspaper he opens up about his ADHD diagnosis which he describes as a "superpower" using music as an escape route to fuel his passion for success.
Artistry
DanimaL's style of rap is predominantly 'off-kilter' with a knack for using personal experiences and stories in a tongue-in-cheek format. His main influences in the UK scene come courtesy of Chester P, Skinnyman, Roots Manuva, Rodney P and Lowkey plus more of the pioneers of the UK hip hop sound and culture. In a Q & A by On: Yorkshire Magazine he mentions the importance of owning his accent and states "it's always funny hearing peoples’ reactions when seeing a bearded looking fella rapping in a heavy Yorkshire accent wearing a hi-vis".
Discography
EPs
Status Quo (2019)
Tales of A Scumbag (2020)
Singles
"Homeless" (2017)
"Falling" (2018)
"Growth" (2018)
"Verocai" (2019)
"Elevate" (2019)
"Goat" (2019)
"Adderall" (2019)
"Righteous" (2019)
"Lost" (2019)
"Aristocrats" (2020)
"ADHD" (2021)
"0114" (2021)
"Accolades" (2021)
Guest appearances
Urban Linkz - Return Of The Underground Volume 1
Urban Linkz - Return of The Underground Volume 2
Radio appearances
Itch FM – DJ Captain Co. – HipHop Ahoy (2019)
BBC Radio Sheffield – Toby Foster – Breakfast Show (2021)
References
External links
1994 births
Living people
Musicians from Sheffield
English male rappers
|
```javascript
import React from 'react';
import toNumber from 'lodash/toNumber';
import Input from '../../../../form/Input';
import Row from '../../../../form/Grid/Row';
import LeftColumn from '../../../../form/Grid/LeftColumn';
import RightColumn from '../../../../form/Grid/RightColumn';
const defaultConstraints = {
min: 0,
max: 1000,
};
export default ({ constraints = {}, onUpdate, nestedLevel }) => {
const {
min = defaultConstraints.min,
max = defaultConstraints.max,
} = constraints;
const updateMin = (evt) => {
onUpdate({ min: toNumber(evt.target.value) });
};
const updateMax = (evt) => {
onUpdate({ max: toNumber(evt.value) });
};
return (
<Row>
<Row>
<LeftColumn nestedLevel={nestedLevel}>Min</LeftColumn>
<RightColumn>
<Input
type="number"
onChange={updateMin}
value={min}
/>
</RightColumn>
</Row>
<Row>
{/* TODO nested */}
<LeftColumn nestedLevel={1}>Max</LeftColumn>
<RightColumn>
<Input
type="number"
onChange={updateMax}
value={max}
/>
</RightColumn>
</Row>
</Row>
);
};
```
|
Integrator complex subunit 8 is a protein that in humans is encoded by the INTS8 gene.
References
Further reading
|
Eutetras is a genus of Mexican flowering plants in the daisy family.
Species
Eutetras palmeri A.Gray- Zacatecas, Aguascalientes
Eutetras pringlei Greenm. - Guanajuato, Hidalgo
References
Asteraceae genera
Endemic flora of Mexico
Perityleae
|
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import com.beloo.widget.chipslayoutmanager.SpanLayoutChildGravity;
/** class which determines child gravity inside row from child position */
public interface IChildGravityResolver {
@SpanLayoutChildGravity
int getItemGravity(int position);
}
```
|
Kule is a village in Ghanzi District of Botswana. It is located close to the border with Namibia and has a primary school, clinic, customary court, social and development offices, animal health and production and police offices. The population was 741 in 2001 census.
References
Ghanzi District
Villages in Botswana
|
Angelo Carletti di Chivasso was a noted moral theologian of the Order of Friars Minor; born at Chivasso in Piedmont, in 1411; and died at Coni, in Piedmont, in 1495.
His name in Latin is usually given as Angelus de Clavasio (Clavasium being the Latin name of his birthplace). This form is preserved in bibliographic usage.
Life
Antonio Carletti was born in 1411 to a noble family of Chivasso, Italy, near Turin. He attended the University of Bologna, where he received the degree of Doctor of Civil and Canon Law, and served as a magistrate in the Court of Chiavasso. He was appointed to the Senate by the Marquis of Monferrato Gian Giacomo. It was probably at the age of thirty that he entered the Order of Friars Minor at Santa Maria del Monte in Genoa, taking the name Angelo. There he met Francesco della Rovere, who was later to become Pope Sixtus IV.
In 1467 he accompanied Fra Pietro da Napoli, who had been charged by the Vicar General to reorder the Franciscan province of Austria.
In 1472 he was chosen to fill the office of Vicar-General of that branch of the Order then known as the Cismontane Observance, founded by Bernadine of Siena. He held that office again in 1478, in 1485 and in 1490. He founded the monasteries of Saluzzo, Mondovì and Pinerolo; and preached in Mantua, Genoa, Cuneo, Susa, Monferrato and Turin at the court of Charles I, Duke of Savoy. He also served as a spiritual counselor for Catherine of Genoa and Paola Gambara.
Apostolic Nuncio
In 1480 the Ottoman Empire under Mehmed II took possession of Otranto, and threatened to overrun and lay waste the area. Angelo was appointed Apostolic Nuncio by Pope Sixtus IV, and commissioned to preach a crusade against the invaders. While the residents of Otranto held out under siege, Mehmed II died and the Turkish forces retired from the Italian peninsula.
Again, in 1491, he was appointed Apostolic Nuncio and Commissary by Innocent VIII, conjointly with the Bishop of Mauriana, and reached a peaceful agreement between Catholics and Waldensians.
Angelo Carletti di Chivasso died on April 11, 1495, at the convent of St. Anthony at Cuneo.
Writings
In theology he is considered a major adherent of Scotism. His works are given by Wadding in the latter's "Scriptores Ordinis Minorum". The most noted of these is the "Summa de Casibus Conscientiae", called after him the "Summa Angelica". The basis of this work was a "Summa Confessorum" by John Rumsik, O. P., Lector of Freiburg (d. 1314), which was then arranged alphabetically by Bartholomew of San Concordio who also added material on canon law. The first edition of di Chivasso's "Summa Angelica" appeared in the year 1486, and from that year to the year 1520 it went through 31 editions, 25 of which are preserved in the Royal Library at Munich.
The "Summa" is divided into 659 articles arranged in alphabetical order and forming what would now be called a dictionary of moral theology. The most important of these articles is the one entitled "Interrogationes in Confessione". It serves, in a way, as a dictionary of moral theology and was found very useful for confessors. Judging the character of the work of Bl. Angelo as a theologian from this, his most important contribution to moral theology, one is impressed with the gravity and fairness that characterized his opinions throughout. The "Summa" is a valuable guide in matters of conscience and approaches closely, in the treatment of the various articles, to casuistic theology as this science is now understood, hence the title of the work, "Summa de Casibus Conscientiae".
Martin Luther considered it a symbol of Catholic orthodoxy and had it publicly burned in the public square outside Wittenberg's Elster Gate on December 10, 1520, together with the Bull of Excommunication Exsurge Domine, the Corpus of Canon Law, and Johann Eck's "Chrysopassus".
Editions
Summa angelica de casibus conscientiae. Chivasso: Jacobinus Suigus, de Suico. 1486.
Veneration
On April 14, 1753, Pope Benedict XIII beatified Angelo Carletti, giving official approval to the cult that had for long been paid to Angelo, especially by the people of Chivasso and Coni. The latter chose him as their special patron. His feast is kept on 12 April. He is celebrated in his native Chivasso, with an old country fair each year at the end of August.
References
External links
digital Summa de angelica. - Nürnberg : Anton Koberger, 10.02.1492.
Works of O.F.M Angelus de Clavasio at the National Library of Portugal
1411 births
1495 deaths
People from Chivasso
Italian beatified people
Italian Friars Minor
15th-century venerated Christians
Scotism
15th-century Italian Roman Catholic theologians
15th-century Italian writers
Beatifications by Pope Benedict XIV
|
The Honours of the Principality of Wales are the regalia used at the investiture of the Prince of Wales, as heir apparent to the British throne, made up of a coronet, a ring, a rod, a sword, a girdle and a mantle. All but the coronet date from the investiture of Prince Edward (later Edward VIII then Duke of Windsor) in 1911 when most of the Honours of Wales were redesigned.
The present coronet takes the form laid down in a royal warrant issued by Charles II in 1677, which states, "The son and heir apparent of the Crown shall use and bear his coronet of crosses and fleurs-de-lis with one arch and a ball and cross". Within the frame, which is made of gold, is a velvet cap lined with ermine. The present coronet was made for the investiture of Charles, Prince of Wales (later Charles III) in 1969 as the Coronet of George was still in the possession of the Duke of Windsor who was living in exile in France. The defunct coronet and its predecessor the Coronet of Frederick are now a part of the Crown Jewels in the Jewel House at the Tower of London. The original coronets as worn by the Welsh rulers of the Kingdom of Gwynedd and other Welsh principalities have been lost. Llywelyn's coronet was seized by the king of England in 1284 and is known only to history. The fates of the coronets of the rulers of the other princely states, if they ever had them, are not known.
The regalia were on display at the National Museum of Wales from 1974 until 2011 when they were put into storage at St James's Palace, London. The coronet and rod were both put on permanent display in the Jewel House at the Tower of London in 2020.
See also
Investiture of the Prince of Wales
References
External links
Honours of the Principality of Wales at the Royal Family website
1911 establishments in Wales
1911 works
National symbols of Wales
Royal Collection of the United Kingdom
Principality of Wales
|
is a former Japanese football player. She played for the Japan national team.
National team career
Hase was born on October 25, 1956. In June 1981, she was selected Japan national team for 1981 AFC Championship. At this competition, on June 7, she debuted against Chinese Taipei. This was the Japan team's first match in an International A Match. She played in two matches at this championship. In September, she also played against Italy. However Japan was defeated in this match by a score of 0–9. This was the biggest defeat in the history of the Japan national team. She played three games for Japan in 1981.
National team statistics
References
1956 births
Living people
Japanese women's footballers
Japan women's international footballers
Women's association football goalkeepers
|
```javascript
/**
* This class is the root stub for managing a `ViewModel`.
* @private
*/
Ext.define('Ext.app.bind.RootStub', {
extend: 'Ext.app.bind.AbstractStub',
requires: [
'Ext.app.bind.LinkStub',
'Ext.app.bind.Stub'
],
isRootStub: true,
depth: 0,
createRootChild: function (name, direct) {
var me = this,
owner = me.owner,
ownerData = owner.getData(),
children = me.children,
previous = children && children[name],
parentStub = previous ? null : me,
parentVM, stub;
if (direct || ownerData.hasOwnProperty(name) || !(parentVM = owner.getParent())) {
stub = new Ext.app.bind.Stub(owner, name, parentStub);
} else {
stub = new Ext.app.bind.LinkStub(owner, name, previous ? null : parentStub);
stub.link('{' + name + '}', parentVM);
}
if (previous) {
previous.graft(stub);
}
return stub;
},
createStubChild: function(name) {
return this.createRootChild(name, true);
},
descend: function (path, index) {
var me = this,
children = me.children,
pos = index || 0,
name = path[pos++],
ret = (children && children[name]) || me.createRootChild(name);
if (pos < path.length) {
ret = ret.descend(path, pos);
}
return ret;
},
getFullName: function () {
return this.fullName || (this.fullName = this.owner.id + ':');
},
// The root Stub is associated with the owner's "data" object
getDataObject: function () {
return this.owner.data;
},
getRawValue: function () {
return this.owner.data;
},
getValue: function () {
return this.owner.data;
},
isDescendantOf: function () {
return false;
},
isLoading: function () {
return false;
},
set: function (value) {
//<debug>
if (!value || value.constructor !== Object) {
Ext.Error.raise('Only an object can be set at the root');
}
//</debug>
var me = this,
children = me.children || (me.children = {}),
owner = me.owner,
data = owner.data,
parentVM = owner.getParent(),
linkStub, stub, v, key;
for (key in value) {
//<debug>
if (key.indexOf('.') >= 0) {
Ext.Error.raise('Value names cannot contain dots');
}
//</debug>
if ((v = value[key]) !== undefined) {
if (!(stub = children[key])) {
stub = new Ext.app.bind.Stub(owner, key, me);
} else if (stub.isLinkStub) {
if (!stub.getLinkFormulaStub()) {
// Pass parent=null since we will graft in this new stub to replace us:
linkStub = stub;
stub = new Ext.app.bind.Stub(owner, key);
linkStub.graft(stub);
}
}
stub.set(v);
} else if (data.hasOwnProperty(key)) {
delete data[key];
stub = children[key];
if (stub && !stub.isLinkStub && parentVM) {
stub = me.createRootChild(key);
}
stub.invalidate(true);
}
}
},
schedule: Ext.emptyFn,
unschedule: Ext.emptyFn
});
```
|
```c++
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. path_to_url
#include "core/fxge/android/cfx_androidfontinfo.h"
#include "core/fxcrt/fx_system.h"
#include "core/fxge/android/cfpf_skiafont.h"
#include "core/fxge/android/cfpf_skiafontmgr.h"
#include "core/fxge/cfx_fontmapper.h"
CFX_AndroidFontInfo::CFX_AndroidFontInfo() : m_pFontMgr(nullptr) {}
CFX_AndroidFontInfo::~CFX_AndroidFontInfo() {}
bool CFX_AndroidFontInfo::Init(CFPF_SkiaFontMgr* pFontMgr) {
if (!pFontMgr)
return false;
pFontMgr->LoadSystemFonts();
m_pFontMgr = pFontMgr;
return true;
}
bool CFX_AndroidFontInfo::EnumFontList(CFX_FontMapper* pMapper) {
return false;
}
void* CFX_AndroidFontInfo::MapFont(int weight,
bool bItalic,
int charset,
int pitch_family,
const char* face) {
if (!m_pFontMgr)
return nullptr;
uint32_t dwStyle = 0;
if (weight >= 700)
dwStyle |= FXFONT_BOLD;
if (bItalic)
dwStyle |= FXFONT_ITALIC;
if (FontFamilyIsFixedPitch(pitch_family))
dwStyle |= FXFONT_FIXED_PITCH;
if (FontFamilyIsScript(pitch_family))
dwStyle |= FXFONT_SCRIPT;
if (FontFamilyIsRoman(pitch_family))
dwStyle |= FXFONT_SERIF;
return m_pFontMgr->CreateFont(face, charset, dwStyle);
}
void* CFX_AndroidFontInfo::GetFont(const char* face) {
return nullptr;
}
uint32_t CFX_AndroidFontInfo::GetFontData(void* hFont,
uint32_t table,
uint8_t* buffer,
uint32_t size) {
if (!hFont)
return 0;
return static_cast<CFPF_SkiaFont*>(hFont)->GetFontData(table, buffer, size);
}
bool CFX_AndroidFontInfo::GetFaceName(void* hFont, ByteString* name) {
if (!hFont)
return false;
*name = static_cast<CFPF_SkiaFont*>(hFont)->GetFamilyName();
return true;
}
bool CFX_AndroidFontInfo::GetFontCharset(void* hFont, int* charset) {
if (!hFont)
return false;
*charset = static_cast<CFPF_SkiaFont*>(hFont)->GetCharset();
return false;
}
void CFX_AndroidFontInfo::DeleteFont(void* hFont) {}
```
|
The Seoul frog or Seoul pond frog (Pelophylax chosenicus) is a species of true frog found on the southern and western Korean Peninsula to Shenyang, China. . It is closely related to the eastern golden frog, P. plancyi, and was long considered a subspecies thereof. Also known as gold-spotted pond frog, it is in fact not a true pond frog of genus Rana, but belongs to the water frogs now again separated in Pelophylax.
Adult Seoul frogs are roughly 6 centimeters in length. The back is bright green and bumpy, with patches of light brown; the belly is yellowish-red. The iris of the eye is golden. The body as a whole is round as if swollen.
The Seoul frog is found in ponds and rice paddies, but has been declining sharply, probably due to habitat degradation. According to Matsui (2004), recent surveys have located populations in only four locations. The mating season is from mid-May to June.
The Seoul frog is listed as an "Endangered category II species" in South Korea.
References
Pelophylax
Amphibians of Korea
Endemic fauna of Korea
Amphibians described in 1931
|
Carl (or Karl) Heinrich Gustav Julius von Halfern (8 April 1873 – 20 October 1937) was a German administrative lawyer. He was the district administrator of the Saarbrücken district (1916–19), the Regional President of Hildesheim (1922–27) and of Stettin (1927–30) and Oberpräsident of the Prussian Province of Pomerania (1930–33). A member of the German People's Party, he was removed as Oberpräsident shortly after the Nazi Party came into power.
Early life
Born in Burtscheid (today, part of Aachen) the son of a cloth manufacturer, bank director and district administrator, Halfern attended the and the Kaiser-Wilhelm-Gymnasium (today, ) in Aachen. He obtained his Abitur in 1893 and then studied law at the University of Strassburg, the Humboldt University of Berlin and the University of Bonn. He was a member of the Student Corps Rhenania Strassburg. He passed his Referendar examination and began a legal clerkship at the district court at Eschweiler and the regional court at Aachen in September 1897. Halfern received his doctorate in law in December 1897 at the Friedrich-Alexander University of Erlangen. He then performed his mandatory military service as a one-year volunteer with the 5th (Westphalian) Uhlan Regiment, headquartered in Düsseldorf. He earned the Iron Cross 2nd class and was discharged with the rank of Rittmeister of reserves.
Halfern obtained an entry level legal position with the Prussian civil service at the Düsseldorf Regierungsbezirk (Governmental District) in February 1900. Following completion of his Assessor examination in January 1903, he became a government Assessor at the Tarnowitz (today, Tarnowskie Góry) district office in the Province of Upper Silesia where he remained until April 1906. He then took a leave of absence and undertook a study trip around the world, which took him to Canada, the United States, Mexico, Japan and China. In February 1907, he returned to work in the office of the Regierungspräsident (Regional President) of Münster.
Political career
From July 1909 to June 1916 Halfern was the Landrat (District Administrator) in the Ottweiler district, and from June 1916 to October 1919 he was district administrator and police director in the Saarbrücken district, which was then part of the Prussian Rhine Province. From 1911 to 1919 he also sat as a member of the Rhenish Provincial Landtag. After the end of the First World War and the conclusion of the Treaty of Versailles, Halfern was given the title of Administrative President for the French-occupied Territory of the Saar Basin by the Prussian Interior Minister on 2 October 1919. However on 9 December, the French military administration removed him from office and expelled him from the Saar Territory.
During the Weimar Republic, Halfern joined the German People's Party (DVP) in 1920 and remained a member until the party was disbanded in July 1933. In February 1920 he was appointed Ministerialrat (Ministerial Councilor) on the Privy Finance Council in the Prussian Ministry of Finance and served as general advisor for the implementation of the peace treaty. On 1 October 1922, Halfern succeeded Wilhelm Kutscher as Regierungspräsident in the Hildesheim Regional District, serving until 1 April 1927. He was then transferred to the same post in the Stettin Regional District where he remained until 1 April 1930. In June 1930 he was appointed Oberpräsident of the Province of Pomerania. He was also a member of the Kaiser Wilhelm Society.
After the Nazi seizure of power, as a Prussian Oberpräsident, Halfern was named on 11 July 1933 to the recently reconstituted Prussian State Council by Prussian Minister president Hermann Göring. However, soon he was placed on leave of absence from his post in Pomerania and formally retired on 1 October 1933. However, he continued to sit as a member of the State Council and was also given a seat on the State Debt Committee in Berlin, holding both these positions until his death on 20 October 1937.
References
Sources
Carl von Halfern entry in Das Deutsche Führerlexikon 1934-1935
Karl von Halfern entry in Saarland Biographie
1873 births
1937 deaths
Corps students
20th-century German civil servants
20th-century German lawyers
German People's Party politicians
Humboldt University of Berlin alumni
Members of the Prussian State Council (Nazi Germany)
Politicians from Aachen
Recipients of the Iron Cross, 2nd class
University of Bonn alumni
University of Erlangen-Nuremberg alumni
University of Strasbourg alumni
|
The 51st (Highland) Searchlight Regiment, Royal Artillery was a Scottish unit of Britain's Territorial Army (TA) formed for air defence just before World War II. It later served as an anti-aircraft (AA) artillery unit in the North West Europe Campaign 1944–45, and continued in the postwar TA into the 1950s.
Origin
The unit's origin lay in two independent AA Companies of the Royal Engineers (RE) formed in Aberdeen and Dundee in 1935 and equipped with searchlights. During the expansion of TA air defence units after the Munich Crisis, the two were combined on 1 November 1938 into a new 51st (Highland) AA Battalion, RE and a third company raised, giving the battalion the following organisation:
HQ Company at Drill Hall, Bell St, Dundee
319 (City of Aberdeen) AA Company, Fonthill Barracks, Aberdeen
320 (City of Dundee) AA Company, Drill Hall, Bell St, Dundee
404 AA Company, Cowdenbeath
Major W.C.G. Black, MC, TD, officer commanding 20th (Fife & Forfar Yeomanry) Armoured Car Company, was promoted to lieutenant-colonel to command the new battalion on 12 October 1938.
In February 1939 the TA's AA units came under the control of a new Anti-Aircraft Command.
World War II
Mobilisation
In June 1939 a partial mobilisation of TA units was begun in a process known as 'couverture', whereby each AA unit did a month's tour of duty in rotation to man selected AA and searchlight positions. On 24 August, ahead of the declaration of war, AA Command was fully mobilised at its war stations. Shortly after mobilisation, 51st AA Bn was assigned of 52nd Light Anti-Aircraft Brigade, a new formation being organised at Stirling with responsibility for searchlight provision within 3rd AA Division covering Scotland.
In February 1940, the battalion provided a cadre of experienced officers and men to help form a new 474 S/L Bty in 5th AA Division.
51st S/L Regiment
On 1 August 1940 the RE searchlight battalions were transferred to the Royal Artillery (RA), and the unit was redesignated 51st (Highland) Searchlight Regiment, RA (TA). It remained with 52 AA Bde in 3 AA Division throughout the Battle of Britain and The Blitz (when Clydebank was badly hit).
547 Searchlight Bty joined on 23 January 1941, having been formed at 232nd S/L Training Rgt at Devizes on 16 January (with a cadre provided by 40th (Sherwood Foresters) S/L Rgt) and spent just a few days under command of 54th (Durham Light Infantry) S/L Rgt. 51st (Highland) S/L Rgt in turn sent a cadre to 234th S/L Training Rgt at Carlisle, where they were to form a new 564 S/L Bty on 17 April 1941, but this was cancelled.
124th LAA Regiment
Home Defence
On 14 February 1942, the regiment was converted to the Light Anti-Aircraft (LAA) artillery role as 124 (Highland) Light Anti-Aircraft Regiment, RA (TA); 319, 320, 404 and 547 S/L Btys became 411, 412, 404 and 413 LAA Btys respectively. The inexperienced 413 LAA Bty (ex-547 S/L Bty) was sent to 237th LAA Training Rgt at Holywood in Northern Ireland.
During May 1942, 124th LAA Rgt completed its re-equipment and training, and joined 30th (Northumbrian) AA Bde, covering Tyneside and Sunderland in 7th AA Division. 413 LAA Battery, for example, was sent to Seaham Holiday Camp, from where it took over operational sites in the Sunderland area and established its Battery HQ at Whitburn Hall, Whitburn. However, in September 1942, 413 LAA Bty left 124th LAA Rgt to join 143rd LAA Rgt in Essex (formally transferring on 3 October), while the rest of the regiment moved to 47th AA Bde at Southampton.
By March 1943, the regiment had moved again, to 5 AA Bde in the Gloucester area, but had left AA Command by August 1943 and joined Second Army forming in England for Operation Overlord.
North West Europe
LAA regiments at this time comprised three batteries of three troops, each equipped with six towed Bofors 40 mm guns using 'Stiffkey Stick' sights. As a mobile unit, 124th LAA would also have had a Royal Electrical And Mechanical Engineers (REME) workshop and a detachment of the Royal Corps of Signals.
124 LAA Regiment went to Normandy in late August 1944 as part of 75th Anti-Aircraft Brigade, which immediately took over AA defence for the Caen area, including the Caen Canal and River Orne bridges. Two weeks later, Canadian troops captured Ostend, and 124 LAA Rgt with the rest of 75 AA Bde moved up the coast to defend it. In November it moved again, to guard the Scheldt estuary, and when the war ended the bulk of 124 LAA Rgt was on the south bank of the Scheldt under 75 AA Bde, with 411 Bty detached to the north bank under 76th AA Bde.
On 9 January 1945, four Bofors of 411 LAA Bty hit and sank a German Biber midget submarine operating off South Beveland. The regiment also manned the Bofors guns on two Landing Craft Flak operating in the estuary under with searchlights provided by 1st S/L Rgt. The battery remained with 76 AA Bde in the final weeks of the war.
After VE Day, the whole of 124 LAA Rgt came under command of 76 AA Bde as it moved into Germany to garrison the Dortmund–Bochum area under I Corps. After 76 AA Bde completed its disbandment in the first two weeks of April 1946, 124 LAA Rgt stayed on as part of British Army of the Rhine, but was placed in suspended animation on 8 June.
Postwar
When the TA was reconstituted on 1 January 1947, the regiment was reformed as 586 (Highland) LAA Regiment, RA, with HQ at Dundee and forming part of 78th AA Bde (the former 52 AA Bde) based in Perth.
In March 1949, the regiment was redesignated again, as 586 (Highland) LAA/Searchlight Regiment, RA.
When Anti-Aircraft Command was disbanded in March 1955, 586 Rgt was absorbed into 276th (Highland) Field Regiment, RA.
Honorary Colonel
Honorary Capt C.A. Carlow, a retired Volunteer officer, was appointed Honorary Colonel of the battalion on 12 October 1938.
Insignia
124 LAA Regiment wore a regimental shoulder flash consisting of a Scottish saltire in the RE colours of blue on red.
Notes
References
Maj L. F. Ellis, History of the Second World War, United Kingdom Military Series: Victory in the West, Vol I: The Battle of Normandy, London: HM Stationery Office, 1962/Uckfield: Naval & Military, 2004, .
Major L.F. Ellis, History of the Second World War, United Kingdom Military Series: Victory in the West, Vol II: The Defeat of Germany, London: HM Stationery Office, 1968/Uckfield: Naval & Military, 2004, .
Gen Sir Martin Farndale, History of the Royal Regiment of Artillery: The Years of Defeat: Europe and North Africa, 1939–1941, Woolwich: Royal Artillery Institution, 1988/London: Brasseys, 1996, .
J.B.M. Frederick, Lineage Book of British Land Forces 1660–1978, Vol II, Wakefield: Microform Academic, 1984, .
Norman E.H. Litchfield, The Territorial Artillery 1908–1988 (Their Lineage, Uniforms and Badges), Nottingham: Sherwood Press, 1992, .
Brig N.W. Routledge, History of the Royal Regiment of Artillery: Anti-Aircraft Artillery 1914–55, London: Royal Artillery Institution/Brassey's, 1994, .
Graham E. Watson & Richard A. Rinaldi, The Corps of Royal Engineers: Organization and Units 1889–2018, Tiger Lily Books, 2018, .
Online sources
British Army units from 1945 on
British Military History
Orders of Battle at Patriot Files
The Royal Artillery 1939–45
Graham Watson, The Territorial Army 1947
Military units and formations established in 1938
Military units and formations in Dundee
Searchlight regiments of the Royal Artillery
Scottish regiments
|
Bonnie MacDougal is the author of four novels that draw extensively from her own life as a lawyer working in Philadelphia.
She received her undergraduate degree from Bryn Mawr College, magna cum laude with Honors in English literature, and her law degree from the University of Pennsylvania.
Her law career took her to Anchorage, Alaska, and Little Rock, Arkansas (where she was one of the few lawyers ever to practice with Bill Clinton), then back to Philadelphia and the firms of Schnader, Harrison, Segal & Lewis, and Pepper Hamilton LLP, where she practices today. Her specialty is complex commercial litigation, including bankruptcy, securities fraud, and intellectual property disputes.
She made her literary debut in 1996 with the publication of Breach of Trust, described as "an extraordinarily accomplished first novel". Her second book was Angle of Impact, a thriller about an aviation disaster, which was described as "a deliciously complicated puzzle" and "one hot read". Her third novel, Out of Order, is the story of a young woman with a secret past who is unwillingly thrust into the limelight when her husband runs for Congress. Out of Order was called "much more than an ordinary legal thriller. It's an ambitious, superbly crafted tale". Another critic wrote: "MacDougal is no female Grisham. She’s more like Scott Turow, a much better lawyer-writer whose characters come loaded with plenty of history". Her fourth novel is Common Pleas, a story of young lovers on trial for the murder of the girl's wealthy parents. Her books have been translated into eight foreign languages.
References
American lawyers
Novelists from Philadelphia
Living people
American women novelists
20th-century American novelists
American women lawyers
20th-century American women writers
Year of birth missing (living people)
Bryn Mawr College alumni
University of Pennsylvania Law School alumni
21st-century American women
|
```go
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package gps
import (
"reflect"
"sort"
"testing"
)
func TestLockedProjectSorting(t *testing.T) {
// version doesn't matter here
lps := []LockedProject{
NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0"), nil),
NewLockedProject(mkPI("foo"), NewVersion("nada"), nil),
NewLockedProject(mkPI("bar"), NewVersion("zip"), nil),
NewLockedProject(mkPI("qux"), NewVersion("zilch"), nil),
}
lps2 := make([]LockedProject, len(lps))
copy(lps2, lps)
sort.SliceStable(lps2, func(i, j int) bool {
return lps2[i].Ident().Less(lps2[j].Ident())
})
// only the two should have switched positions
lps[0], lps[2] = lps[2], lps[0]
if !reflect.DeepEqual(lps, lps2) {
t.Errorf("SortLockedProject did not sort as expected:\n\t(GOT) %s\n\t(WNT) %s", lps2, lps)
}
}
func TestLockedProjectsEq(t *testing.T) {
lps := []LockedProject{
NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0").Pair("REV"), []string{"gps"}),
NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0").Pair("REV"), nil),
NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0").Pair("REV"), []string{"gps", "flugle"}),
NewLockedProject(mkPI("foo"), NewVersion("nada").Pair("OTHERREV"), []string{"foo"}),
NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0").Pair("REV"), []string{"flugle", "gps"}),
NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0").Pair("REV2"), []string{"gps"}),
NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.11.0").Pair("REV"), []string{"gps"}),
NewLockedProject(mkPI("github.com/sdboyer/gps"), Revision("REV2"), []string{"gps"}),
}
fix := map[string]struct {
l1, l2 int
shouldeq bool
err string
}{
"with self": {0, 0, true, "lp does not eq self"},
"with different revision": {0, 5, false, "should not eq with different rev"},
"with different versions": {0, 6, false, "should not eq with different version"},
"with same revsion": {5, 5, true, "should eq with same rev"},
"with empty pkg": {0, 1, false, "should not eq when other pkg list is empty"},
"with long pkg list": {0, 2, false, "should not eq when other pkg list is longer"},
"with different orders": {2, 4, false, "should not eq when pkg lists are out of order"},
"with different lp": {0, 3, false, "should not eq totally different lp"},
"with only rev": {7, 7, true, "should eq with only rev"},
"when only rev matches": {5, 7, false, "should not eq when only rev matches"},
}
for k, f := range fix {
k, f := k, f
t.Run(k, func(t *testing.T) {
if f.shouldeq {
if !lps[f.l1].Eq(lps[f.l2]) {
t.Error(f.err)
}
if !lps[f.l2].Eq(lps[f.l1]) {
t.Error(f.err + (" (reversed)"))
}
} else {
if lps[f.l1].Eq(lps[f.l2]) {
t.Error(f.err)
}
if lps[f.l2].Eq(lps[f.l1]) {
t.Error(f.err + (" (reversed)"))
}
}
})
}
}
func TestLockedProjectsString(t *testing.T) {
tt := []struct {
name string
lp LockedProject
want string
}{
{
name: "full info",
lp: NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0"), []string{"gps"}),
want: "github.com/sdboyer/gps@v0.10.0 with packages: [gps]",
},
{
name: "empty package list",
lp: NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0"), []string{}),
want: "github.com/sdboyer/gps@v0.10.0 with packages: []",
},
{
name: "nil package",
lp: NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0"), nil),
want: "github.com/sdboyer/gps@v0.10.0 with packages: []",
},
{
name: "with source",
lp: NewLockedProject(
ProjectIdentifier{ProjectRoot: "github.com/sdboyer/gps", Source: "github.com/another/repo"},
NewVersion("v0.10.0"), []string{"."}),
want: "github.com/sdboyer/gps (from github.com/another/repo)@v0.10.0 with packages: [.]",
},
{
name: "version pair",
lp: NewLockedProject(mkPI("github.com/sdboyer/gps"), NewVersion("v0.10.0").Pair("278a227dfc3d595a33a77ff3f841fd8ca1bc8cd0"), []string{"gps"}),
want: "github.com/sdboyer/gps@v0.10.0 with packages: [gps]",
},
{
name: "revision only",
lp: NewLockedProject(mkPI("github.com/sdboyer/gps"), Revision("278a227dfc3d595a33a77ff3f841fd8ca1bc8cd0"), []string{"gps"}),
want: "github.com/sdboyer/gps@278a227dfc3d595a33a77ff3f841fd8ca1bc8cd0 with packages: [gps]",
},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
s := tc.lp.String()
if tc.want != s {
t.Fatalf("want %s, got %s", tc.want, s)
}
})
}
}
```
|
```makefile
ifeq ($(LOSCFG_ARCH_ARM_CORTEX_M), y)
-include $(LITEOSTOPDIR)/arch/arm/cortex_m/cpu.mk
else
-include $(LITEOSTOPDIR)/arch/arm/cortex_a_r/cpu.mk
endif
```
|
```html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>ssl::context_base::options</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../boost_asio.html" title="Boost.Asio">
<link rel="up" href="../ssl__context_base.html" title="ssl::context_base">
<link rel="prev" href="no_tlsv1_2.html" title="ssl::context_base::no_tlsv1_2">
<link rel="next" href="password_purpose.html" title="ssl::context_base::password_purpose">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="path_to_url">People</a></td>
<td align="center"><a href="path_to_url">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="no_tlsv1_2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ssl__context_base.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../boost_asio.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="password_purpose.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_asio.reference.ssl__context_base.options"></a><a class="link" href="options.html" title="ssl::context_base::options">ssl::context_base::options</a>
</h4></div></div></div>
<p>
<a class="indexterm" name="boost_asio.indexterm.ssl__context_base.options"></a>
Bitmask
type for SSL options.
</p>
<pre class="programlisting">typedef long options;
</pre>
<h6>
<a name="boost_asio.reference.ssl__context_base.options.h0"></a>
<span class="phrase"><a name="boost_asio.reference.ssl__context_base.options.requirements"></a></span><a class="link" href="options.html#boost_asio.reference.ssl__context_base.options.requirements">Requirements</a>
</h6>
<p>
<span class="emphasis"><em>Header: </em></span><code class="literal">boost/asio/ssl/context_base.hpp</code>
</p>
<p>
<span class="emphasis"><em>Convenience header: </em></span><code class="literal">boost/asio/ssl.hpp</code>
</p>
</div>
<table xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
file LICENSE_1_0.txt or copy at <a href="path_to_url" target="_top">path_to_url
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="no_tlsv1_2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ssl__context_base.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../boost_asio.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="password_purpose.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
```
|
Bambarabedde Devainnegama is a village in Sri Lanka. It is located within Central Province.
See also
List of towns in Central Province, Sri Lanka
External links
Populated places in Kandy District
|
```sqlpl
alter table SYS_CATEGORY_ATTR add DEFAULT_DECIMAL numeric(36,10)^
alter table SYS_ATTR_VALUE add DECIMAL_VALUE numeric(36,10)^
alter table SYS_CATEGORY_ATTR add ATTRIBUTE_CONFIGURATION_JSON longvarchar^
```
|
Johanna Doderer (born 18 September 1969 in Bregenz) is an Austrian composer.
Biography
Doderer was born in 1969 in Bregenz, Austria. She is the great-niece of the Austrian novelist Heimito von Doderer and a great-granddaughter of the architect Carl Wilhelm von Doderer. Doderer learned her trade in Graz with Beat Furrer (composition), then later in Vienna with Klaus Peter Sattler (film and media composition) and Erich Urbanner (composition).
Her current work ranges broadly from chamber music to orchestral work and to opera. In the immediate future she intends to concentrate her work in the field of opera.
An important aspect of her artistic career is her frequent collaborations with musicians such as Patricia Kopatchinskaja, Sylvia Khittl-Muhr, Marlis Petersen and Edua Zadory, and with the conductor Ulf Schirmer.
Her work was performed at the Embassy of Austria, Washington, D.C. by violinist Édua Zádory and the Momenta Quartet. In December 2012 the University of Arts Graz (Austria) devoted an entire day to performances of Johanna Doderer's works.
Prizes and residencies
Composer in Residence 2004/2005, Wiener Concertverein
SKE Publicity Preis 2004
Österreichisches Staatsstipendium für Komponistinnen und Komponisten 2002
Kulturpreis der Stadt Feldkirch 2002
Kulturpreis der Stadt Wien (Sparte Musik) 2002
Wiener Symphoniker-Stipendium 2001
Commissions
She has received commissions from organisations including:
Münchner Rundfunkorchester, Wiener Symphoniker, Royal Liverpool Philharmonic (Ensemble 10/10), Brucknerorchester, Haydn-Trio Eisenstadt, Wiener Concerverein, Klangspuren in Schwaz, Bregenzer Festspiele, Festival Montepulciano, ADEvantgarde, Camerata Academica Salzburg, Klangforum Wien, Die Reihe, Pierrot Lunaire Ensemble, Ensemble Europeo Antidogma Musica Torino, Sounding London, Savaria Symphonieorchester Szombathely, Festival Internazionale di Musica Antica e Contemporanea Torino, Festival Nuovi Spazi Musicali Roma, Musikwerkstatt Wien, Ensemble Plus, Open Music Graz, Österreichisches Ensemble für Neue Musik Salzburg, and Ensemble Lux.
Recordings
ORF CD, Johanna Doderer with Ulf Schirmer, Patricia Kopatchinskaja, etc.
For violin and orchestra, Bolero for two pianos and orchestra, Rondane for orchestra, ORF- Shop, order number: 2009336
OEHMS Classics, “Mon cher cousin” with Ulf Schirmer, the Munich Radio Orchester, Salome Kammer, etc., CD made in connection with Augsburg's Mozart Celebration 2008, including Johanna Doderer's “Mon cher cousin” for soprano and orchestra, Oehms Classics OC 714
CAPRICCIO, D2H-Dedicated To Haydn with Haydn Trio Eisenstadt (3 CDs)
CDs made in connection with the opening of the Haydn Year in Eisenstadt in May 2009, including Johanna Doderer's 2nd piano trio (info: www.d2h.at), CAP7020
List of works
Operas
Die Fremde (2000/01; DWV 28). Opera in 1 act. Libretto: Johanna Doderer (after Euripides’ drama Medea). Duration: 70'.
Strom (2002–06; DWV 29). Opera in 1 act. Libretto: Johanna Doderer (after Euripides’ drama The Bacchae). Duration: 110 min.
Falsch verbunden (2006; DWV 43). Short opera. Libretto: Daniel Glattauer. Duration: 15 min.
Der leuchtende Fluss (title in English: A Kind Of Yellow) (2009–2010, DWV 45). Libretto: Wolfgang Hermann. Duration: 150 min
Fatima, (2015) Opera for children. From a story by Rafik Schami
Liliom (2016) Opera. Libretto: (based on the 1909 play Liliom by Ferenc Molnár).
Schubert's Reise nach Atzenbrugg (2021) Opera. Libretto: Peter Turrini.
Orchestral works
Second Symphony, "Bohinj" (49') (2014/15; DWV 93)
Study on Zaha Hadid's Painting "Vison for Madrid" (1992) for orchestra (20') (2008; DWV55)
DER GROSSE REGEN for orchestra (10') (2007; DWV50)
First Symphony (40') (2006-7; DWV47)
Rondane version for large orchestra (15') (2001; DWV26)
Für Orchester orchestra study (6') (1999; DWV19)
Ikarus for string orchestra (15') (1991; DWV9)
Eine Sonnenfinsternis for string orchestra and timpani (20') (1993; DWV4)
Chamber orchestra
Psalm 2 chamber orchestra version (12') (2006; DWV41)
Rondane for chamber orchestra (10') (2000; DWV20)
Skumring for instrumental ensemble (25') (1995; DWV10)
Concertos
Violin Concerto No. 2, "In Breath of Time" (23') (2012; DWV62b)
Violin Concerto (45') (2004/2005; DWV35)
Bolero for 2 pianos and orchestra (30') (2004; DWV36 )
For Orchestra or Violoncello Solo (10') (2000; DWV22)
Chamber music
Second String Quintet (12') (2008; DWV56)
Second Piano Trio (15') (2008; DWV52)
For Accordion and Strings 1 (14') (2006; DWV45)
Work for Cello and Piano (ca.15') (2005; DWV38)
Psalm 2 for string quartet (12') (2005; DWV37)
Piano Trio (15') (2002; DWV31)
erwachen III for 3 violins (30') (2001; DWV27)
silence I for violin and piano (15') (2001; DWV25)
silence II for violin and cello (12') (2001; DWV24)
running for percussion and piano (15') (2001; DWV23)
Stimmen for instrumental ensemble (15') (1999 DWV18)
erwachen II for 3 violins (10') (1998; DWV17)
Feuerkreis for string quintet (16') (1997; DWV15)
Psalm String Quartet (18') (1994; DWV7)
Brennpunkt for strings and Javanese gongs (20') (1994; DWV6)
erwachen I for 3 violins (8') (1993; DWV5)
Fall 2 for instrumental ensemble (15') (1991; DWV2)
Fall 1 for flute, violin and cello (4') (1991; DWV1)
Solo works
Wutmarsch - Fantasy for Piano Solo (4') (2008; DWV51)
For Solo Violin 2 (12') (2007; DWV48)
For Solo Violin (5') (2005; DWV39)
Phantasien über den Grenzwald for piano (8') (2004; DWV34)
Toccata for organ (10') (2003; DWV32)
Early studies
Ziel for violin and cello (2') (1991)
Piece for Two Violins and Cello (4') (1991)
Zwiespalt for Flute and Cello (2') (1991)
Songs and vocal music
Solo voice
Mon cher cousin for soprano and orchestra (2007; DWV49)
Astraios work für mezzo-soprano and chamber orchestra (2006; DWV 42)
Orchestral songs on texts by Wolfgang Hermann for mezzo-soprano (2005; DWV 40)
Mass for Wilhelm Doderer for 2 mezzo-sopranos and organ (12') (2002; DWV 30)
Feuerkreis for soprano, mezzo-soprano and vocal ensemble on texts by Reinhard Kräuter (15') (1998; DWV 16)
Terra for soprano and orchestra (23') (1997; DWV 14)
Terra for soprano and instrumental ensemble (12') (1997; DWV 13)
Rot for soprano, and string quartet on texts by Reinhard Kräuter (15') (1996; DWV 12)
Klänge aus einer verlorenen Zeit for alto, choir, viola and glasses (10') (1994; DWV 8)
Der Verfall, a passion on texts by Georg Trakl for soprano, choir and chamber orchestra (15') (1991; DWV 3)
Songs with piano
Song Cycle (10 Songs) for soprano, baritone and piano on texts by Antonia Pozzi (2009; DWV58)
Orchestral songs for mezzo-soprano on texts by Wolfgang Hermann (piano version) (2005; DWV 40a)
Songs for baritone and piano on texts by Wolfgang Hermann (12') (2003; DWV 33)
Für ein Obdach am Rand aller Sinne song for soprano and piano on a text by Christine Lavant (10'). (2000; DWV 21)
Choir
Three Choral Studies (2006; DWV 46)
Vergessene Erde for choir (1995; DWV11)
References
External links
Personal website
Johanna Doderer Music Information Center Austria
1969 births
Austrian women composers
Austrian classical composers
Living people
Women classical composers
People from Bregenz
20th-century Austrian musicians
20th-century classical composers
21st-century Austrian musicians
21st-century classical composers
20th-century women composers
21st-century women composers
|
Mar Thoma Sleeha Syro-Malabar Church is a pilgrimage church located in Thulappally, Syro-Malabar Catholic Eparchy of Kanjirappally in the Indian state of Kerala. The St. Thomas's feast festivities held there every July attract a number of devotees from in and around Kerala.
About the parish
This catholic church is located in the eastern bank of the River Pampa, a holy river in Hindu mythology. The parish is surrounded by state forests. It is very close to the famous Hindu pilgrimage centers of the Sabarimala Sri Ayyappa Temple and the Nilackal Temple. The first church of Catholics has been established in the year 1956 and it was dedicated to St George. Recently the new church building has been constructed and the church has been dedicated in the name of St Thomas. This is done to show case that the Catholics of this are too are part of St Thomas Christian community which traces its origin to the arrival of St Thomas. The church renaming has been done to attract the pilgrims as the location is near to Nilackal/Chayal.
There are 325 Christian families and about 1850 members in the parish. Around 250 children attend the Sunday catechesis. it has four shrines.
The parish of Angelvalley was once the part of the parish. At the time of its formation, Angelvalley had around 250 families from the Nilackal, Thulapally parish.
The parish is divided into seventeen small groups called Koottayma, each known after a Biblical place such as Jerusalem, Jordan, Emmaus, Hermon, Kapharnaum, Saini, Corinthose, Thesalonica, Nazareth, Alphonsa, Chavara, Galathia, Carmel and Calvary. Nazareth and Carmel have A and B sections. Each of these groups meet weekly for prayer and study classes.
Parish social works are arranged under the 'Malanadu Development Society' which is the social service organization of the Diocese of Kanjirappally. Fifty S.H.G.s (Self Help Groups) get help from the M.D.S. Unit. It has a rural electrification system called 'Malanadu Mycro Hydel Power Project' Thulappally (M.H.P.P.). This power project generates electricity from water and supplies about 250 families, and shops, clinics, temples, mosques and churches. The parish helps milk-producing farmers to sell their milk under M.M.P. (Mahima Milk Producers Union). Under the leadership of M.D.S. Unit of the parish the people of Pampavalley made the longest Rubberized Road in Asia, two large bridges across the rivers Pampa and Azhuta, built many small bridges etc.
A government Primary School called St. Georges L.P.S. Thulappally which is under the management of the parish, and there are non-denominational social service institutions such as M.D.S., M.M.P. and M.H.P.P. serving all regardless of caste. Adoration sisters have their convent near the parish church.
Religious organisations working under the parish
CML
St. Vincent De Paul Society
Youvadeepthy
Mathrudeepthy
Legion of Mary
Institutions under the parish
St. George L.P. School
Syro-Malabar religious houses in the parish
SABS Convent
History
History of Christians here starts from the arrival of St. Thomas the Apostle. The apostle reached Nilakkal at 52 AD and started a Christian Community here. At that time, Nilackal was a 'Trade City' having trade relations with "Pandi-chola" states and 'Venadu'. There were 'Palace Roads' from their countries to 'Nilackal Thavalam' which were illumined by great lights (ex. Keralachaitram : K.P. Padmanabhan P. 145. Thiruvithamcore State mannel Vol. 1-p. 665 Vol. 2-p. 128)
Since Nilackal was a vast region, there were many Christian churches here. Place here were known after the churches there. Even now places in the forests are called Plappally, Thulappally etc. The head Church of all these small churches was called 'Thalappally and later as Thulappally. (cfr. History of Christianity in Kerala by Nagamayyas P. 136). Old tombs of Christians are seen even now in the forest area near the present church unfortunately the invasion of some alien force called 'Vakkrippali attack' the inhabitants of Nilackal fled to other places such as Kanjirappally, Aruvithura, and other parts of the Meenachil . Nilackal is also called 'Chayal' since the place slopes towards the River 'Pampa'.
After a long time migration started to these remote places. It started as early as 1938. The recession felt in the socio-economic spheres after the first world war stimulated the migration to the hilly regions from the places. The majority of the immigrants were Nasranis of Malankara Mar Thoma Syrian church (One of the St Thomas Christian Church) and non – Christians, a substantial number of Catholics also came to those Hillocks. They soon felt the strong need for a Church to meet their spiritual as well as social needs.
A Catholic parish was set up under the leadership of Fr. George Ponnadathukallel. This church was actually dedicated for St George. They offered the first Qurbana in a temporary chapel on 12 February 1955. In 1960 it was officially given the status of a parish and Fr. Joseph Kalayil was appointed as the first Vicar.
New church
The name of the church was St. George from 1956 to 2007. The new church was blessed on 17 January 2007 along with new Name Mar Thoma Sleeha Church, Nilackal Thulappally. Fr.Martin Uppukunnel who was the vicar from 2002 to 2007 lead the work of the new church. The old church was demolished during 2015–2016.
Annual events
AD 52, 21 November – St. Thomas reached India. He started a Christian community at Nilackal
72, 3 July – St. Thomas received martyrdom at Mylappoor.
1938 – Migration Started
1947-48 – Government of Kerala gave the farmers certain area for food production
1955, 12 February– First Holy Qurbana
1960 – Parish erection
1964 – L.P. School
1968 – Parish Church construction started
1975 – Church consecration
1978 – S.A.B.S. Convent started
1984, 7 May – Presbytery
2007, 17 January – Established new church(Mar Thoma Sleeha Church)
St. Thomas Day
St. Thomas Day which celebrates the death of Thomas the Apostle is the most important festival celebrated in the church and is attended by thousands of people. Held every 3 July.
Parish's Day
Parish Day which celebrates the blessing memory of the new church which is happening every year from 17 January to 26 January. Grand celebration will be held in the last day (26 Jan) and mass is attended by thousands of adults and children of Kanjirappally Diocese.
References
External links
Syro Malabar site
List of parishes
Mar Thoma Sleeha Syro-Malabar Church, Thulappally on Facebook
Churches in Pathanamthitta district
Syro-Malabar Catholic church buildings
Eastern Catholic churches in India
Churches completed in 1956
|
The Hall, at times known as Kingston House and The Duke's House, is a Grade I listed Jacobean mansion in Bradford-on-Avon, Wiltshire, England.
History
The Hall was built around 1610 for John Hall, a wealthy mill owner, and is at the east end of the town. The Hall family of Bradford can be traced back to at least the 13th century, under the name of "De Aulâ" or "De la Sale" (salle being french for hall). John Hall's grandson, also named John Hall, had no legitimate children and left his estate to his great-niece Rachel Baynton. She later married William Pierrepont, who became Duke of Kingston-upon-Hull, giving the house its alternate names. After the second Duke died without issue, the house was sold to Thomas Divett, in 1802, who established a woollen mill, and sublet the house, which fell into disrepair. In 1848, the house was sold to Stephen Moulton, who undertook major restorations. During the restoration, many old documents were discovered, which were catalogued by Canon J.E.Jackson.
Architecture
The Hall, in particular the south front, is notable for having "more glass than wall". Not all contemporaries approved of the style. Francis Bacon in On Building refers to "fair houses so full of glass that one cannot tell where to become to be out of the sun or cold". The architect is not known. Similarities of style to Longleat, not far away and built about 30 years earlier, have led to suggestions that Robert Smythson may have been involved in the design.
The building sits high on a terrace. The south front has three projecting bays of two stories, with gables above. The outer two bays are wider than the central one, and have semi-circular projections. Open rings above the bays form a kind of balustrade. The terrace has a balustrade with a central staircase, leading to the main doorway of the house, which has a round arch, flanking Tuscan columns, and scroll-work above. Inside, the ceilings are high, and there are a number of Jacobean chimney-pieces and moulded plaster ceilings.
Gardens
The house stands in grounds of some , which were landscaped in the mid-19th century and recorded at Grade II on the National Register of Historic Parks and Gardens in 1987. John Moulton, the younger son of Stephen Moulton who inherited the estate in 1894, carried out extensive improvements and added many plants and trees. Further improvements were made from the 1960s by John's grandson Alex Moulton, who used the north-east corner of the site for his Moulton bicycle works.
The landscaping is in several sections. Just east of the house, a square lawn is surrounded by a clipped yew hedge. To the west, a path across another lawn leads to a small stone temple, probably 19th-century, having a triangular pediment supported by two Doric columns. South of the house is a large Grade II* listed balustraded terrace with 18th-century stonework, added to in the 19th century. In the far south is an octagonal building in rubble stone, from the late 18th century or early 19th; originally a dovecote, it was later an entrance lodge and is now a dwelling. The eastern parts of the grounds are informal pleasure gardens, with stables (created from a barn by Harold Brakspear in 1901–02) and a paddock; here is another small temple, probably from the 18th century, with four Tuscan columns.
Gallery
Assessment
The Hall has been highly regarded from its early days to the present. John Aubrey (1670) described it as "the best built house for the quality of a gentleman in Wiltshire". W. J. Loftie in 1893 called it the most perfect of the smaller houses in the "second Elizabethan" style. The house was selected as the model for the pavilion which was built for the 1900 Exhibition in Paris.
The house was designated as Grade I listed in 1954. Pevsner and Cherry (1975) refer to it as of national importance.
Present day
After the death in 2012 of Alex Moulton, great-grandson of Stephen Moulton, under the terms of his will the house – along with investments, land, outbuildings and cottages – was gifted to a charitable trust. In 2020 the trust was reorganised as a charitable incorporated organisation, the Alex Moulton Charitable Trust, which continues to preserve and maintain the Hall and its collections, and promote engineering and design. The trust runs occasional tours of the building and holds events in the grounds.
References
External links
The Alex Moulton Charitable Trust
The Hall, Bradford on Avon at freshford.com
Country houses in Wiltshire
Grade I listed buildings in Wiltshire
Buildings and structures completed in the 1600s
Bradford-on-Avon
|
```javascript
import dynamic from 'next/dynamic'
export const NextDynamicNoSSRServerComponent = dynamic(
() => import('../text-dynamic-no-ssr-server'),
{
ssr: false,
}
)
```
|
```yaml
subject: "Match"
description: "=~ operator/with Regexp literal as a LHS (without named capture groups)"
notes: >
Is represented as a method call `/regexp/.=~(argument)`
focused_on_node: "org.truffleruby.language.dispatch.RubyCallNode"
ruby: |
/foo/ =~ bar
ast: |
RubyCallNode
attributes:
descriptor = NoKeywordArgumentsDescriptor
dispatchConfig = PROTECTED
emptyKeywordsProfile = false
flags = 1
isAttrAssign = false
isSafeNavigation = false
isSplatted = false
isVCall = false
lastArgIsNotHashProfile = false
methodName = "=~"
notEmptyKeywordsProfile = false
notRuby2KeywordsHashProfile = false
sourceCharIndex = 0
sourceLength = 12
children:
arguments = [
RubyCallNode
attributes:
descriptor = NoKeywordArgumentsDescriptor
dispatchConfig = PRIVATE
emptyKeywordsProfile = false
flags = 0
isAttrAssign = false
isSafeNavigation = false
isSplatted = false
isVCall = true
lastArgIsNotHashProfile = false
methodName = "bar"
notEmptyKeywordsProfile = false
notRuby2KeywordsHashProfile = false
sourceCharIndex = 9
sourceLength = 3
children:
receiver =
SelfNode
attributes:
flags = 0
sourceCharIndex = -1
sourceLength = 0
]
receiver =
ObjectLiteralNode
attributes:
flags = 0
object = RubyRegexp(source = foo, options = RegexpOptions(kcode: NONE, kcodeDefault, literal), encoding = US-ASCII)
sourceCharIndex = 0
sourceLength = 5
```
|
The Rhaet Hauptton Formation is a geologic formation in Germany. It preserves fossils dating back to the Triassic period.
See also
List of fossiliferous stratigraphic units in Germany
References
Triassic Germany
|
Several steamships have been named Patria.
– later called SS Patria
– sunk in the Patria disaster in 1940 in the Port of Haifa, Mandatory Palestine
See also
Ship names
|
Bupleurum dianthifolium is a species of flowering plant in the family Apiaceae. It is endemic to Italy. Its natural habitat is Mediterranean-type shrubby vegetation. It is threatened by habitat loss.
References
dianthifolium
Flora of Italy
Critically endangered plants
Taxonomy articles created by Polbot
|
```xml
// See LICENSE.txt for license information.
import React from 'react';
import {StyleSheet, View} from 'react-native';
import AddMembersBox from '@components/channel_actions/add_members_box';
import FavoriteBox from '@components/channel_actions/favorite_box';
import InfoBox from '@components/channel_actions/info_box';
import SetHeaderBox from '@components/channel_actions/set_header_box';
type Props = {
channelId: string;
header?: boolean;
favorite?: boolean;
canAddMembers?: boolean;
}
const styles = StyleSheet.create({
container: {
justifyContent: 'center',
flexDirection: 'row',
marginBottom: 8,
marginTop: 28,
width: '100%',
},
margin: {
marginRight: 8,
},
item: {
alignItems: 'center',
borderRadius: 4,
height: 70,
justifyContent: 'center',
maxHeight: undefined,
paddingHorizontal: 16,
paddingVertical: 12,
width: 112,
},
});
const IntroOptions = ({channelId, header, favorite, canAddMembers}: Props) => {
return (
<View style={styles.container}>
{canAddMembers &&
<AddMembersBox
channelId={channelId}
containerStyle={[styles.item, styles.margin]}
testID='channel_post_list.intro_options.add_members.action'
inModal={false}
/>
}
{header &&
<SetHeaderBox
channelId={channelId}
containerStyle={[styles.item, styles.margin]}
testID='channel_post_list.intro_options.set_header.action'
/>
}
{favorite &&
<FavoriteBox
channelId={channelId}
containerStyle={[styles.item, styles.margin]}
testID='channel_post_list.intro_options'
/>
}
<InfoBox
channelId={channelId}
containerStyle={styles.item}
testID='channel_post_list.intro_options.channel_info.action'
/>
</View>
);
};
export default IntroOptions;
```
|
David Bissett (born September 26, 1979) is a Canadian bobsledder who has competed since 2005. Competing in three Winter Olympics, he won a bronze medal in the four-man event at Vancouver in the 2010 Winter Olympics.
He won a silver medal in the four-man event at the 2007 FIBT World Championships in St. Moritz.
Bissett was born in Lethbridge, Alberta, and starred in Canadian football at the University of Alberta in Edmonton. He now resides in Okotoks.
External links
David Bissett at Bobsleigh Canada Skeleton
1979 births
Living people
Alberta Golden Bears football players
Bobsledders at the 2006 Winter Olympics
Bobsledders at the 2010 Winter Olympics
Bobsledders at the 2014 Winter Olympics
Canadian male bobsledders
Medalists at the 2010 Winter Olympics
Olympic bobsledders for Canada
Olympic bronze medalists for Canada
Olympic medalists in bobsleigh
Players of Canadian football from Alberta
Sportspeople from Lethbridge
|
```css
CSS Specificity
Importing a CSS file into another CSS file
Determine the opacity of background-colors using the RGBA declaration
Use attribute selectors with empty links
Disclose file format of links
```
|
```javascript
import {
align,
group,
ifBreak,
indent,
join,
line,
softline,
} from "../../document/builders.js";
import { printComments } from "../../main/comments/print.js";
import { hasSameLocStart } from "../loc.js";
import pathNeedsParens from "../needs-parens.js";
import {
CommentCheckFlags,
createTypeCheckFunction,
hasComment,
hasLeadingOwnLineComment,
isFlowObjectTypePropertyAFunction,
isObjectType,
isSimpleType,
isUnionType,
} from "../utils/index.js";
import { printAssignment } from "./assignment.js";
import {
printFunctionParameters,
shouldGroupFunctionParameters,
} from "./function-parameters.js";
import {
printAbstractToken,
printDeclareToken,
printOptionalToken,
} from "./misc.js";
/**
* @typedef {import("../../document/builders.js").Doc} Doc
*/
const isVoidType = createTypeCheckFunction([
"VoidTypeAnnotation",
"TSVoidKeyword",
"NullLiteralTypeAnnotation",
"TSNullKeyword",
]);
const isObjectLikeType = createTypeCheckFunction([
"ObjectTypeAnnotation",
"TSTypeLiteral",
// This is a bit aggressive but captures Array<{x}>
"GenericTypeAnnotation",
"TSTypeReference",
]);
function shouldHugUnionType(node) {
const { types } = node;
if (types.some((node) => hasComment(node))) {
return false;
}
const objectType = types.find((node) => isObjectLikeType(node));
if (!objectType) {
return false;
}
return types.every((node) => node === objectType || isVoidType(node));
}
function shouldHugType(node) {
if (isSimpleType(node) || isObjectType(node)) {
return true;
}
if (isUnionType(node)) {
return shouldHugUnionType(node);
}
return false;
}
/*
- `DeclareOpaqueType`(flow)
- `OpaqueType`(flow)
*/
function printOpaqueType(path, options, print) {
const semi = options.semi ? ";" : "";
const { node } = path;
const parts = [
printDeclareToken(path),
"opaque type ",
print("id"),
print("typeParameters"),
];
if (node.supertype) {
parts.push(": ", print("supertype"));
}
if (node.impltype) {
parts.push(" = ", print("impltype"));
}
parts.push(semi);
return parts;
}
/*
- `DeclareTypeAlias`(flow)
- `TypeAlias`(flow)
- `TSTypeAliasDeclaration`(TypeScript)
*/
function printTypeAlias(path, options, print) {
const semi = options.semi ? ";" : "";
const { node } = path;
const parts = [printDeclareToken(path)];
parts.push("type ", print("id"), print("typeParameters"));
const rightPropertyName =
node.type === "TSTypeAliasDeclaration" ? "typeAnnotation" : "right";
return [
printAssignment(path, options, print, parts, " =", rightPropertyName),
semi,
];
}
// `TSIntersectionType` and `IntersectionTypeAnnotation`
function printIntersectionType(path, options, print) {
let wasIndented = false;
return group(
path.map(({ isFirst, previous, node, index }) => {
const doc = print();
if (isFirst) {
return doc;
}
const currentIsObjectType = isObjectType(node);
const previousIsObjectType = isObjectType(previous);
// If both are objects, don't indent
if (previousIsObjectType && currentIsObjectType) {
return [" & ", wasIndented ? indent(doc) : doc];
}
// If no object is involved, go to the next line if it breaks
if (!previousIsObjectType && !currentIsObjectType) {
return indent([" &", line, doc]);
}
// If you go from object to non-object or vis-versa, then inline it
if (index > 1) {
wasIndented = true;
}
return [" & ", index > 1 ? indent(doc) : doc];
}, "types"),
);
}
// `TSUnionType` and `UnionTypeAnnotation`
function printUnionType(path, options, print) {
const { node } = path;
// single-line variation
// A | B | C
// multi-line variation
// | A
// | B
// | C
const { parent } = path;
// If there's a leading comment, the parent is doing the indentation
const shouldIndent =
parent.type !== "TypeParameterInstantiation" &&
(parent.type !== "TSConditionalType" || !options.experimentalTernaries) &&
(parent.type !== "ConditionalTypeAnnotation" ||
!options.experimentalTernaries) &&
parent.type !== "TSTypeParameterInstantiation" &&
parent.type !== "GenericTypeAnnotation" &&
parent.type !== "TSTypeReference" &&
parent.type !== "TSTypeAssertion" &&
parent.type !== "TupleTypeAnnotation" &&
parent.type !== "TSTupleType" &&
!(
parent.type === "FunctionTypeParam" &&
!parent.name &&
path.grandparent.this !== parent
) &&
!(
(parent.type === "TypeAlias" ||
parent.type === "VariableDeclarator" ||
parent.type === "TSTypeAliasDeclaration") &&
hasLeadingOwnLineComment(options.originalText, node)
);
// {
// a: string
// } | null | void
// should be inlined and not be printed in the multi-line variant
const shouldHug = shouldHugType(node);
// We want to align the children but without its comment, so it looks like
// | child1
// // comment
// | child2
const printed = path.map((typePath) => {
let printedType = print();
if (!shouldHug) {
printedType = align(2, printedType);
}
return printComments(typePath, printedType, options);
}, "types");
if (shouldHug) {
return join(" | ", printed);
}
const shouldAddStartLine =
shouldIndent && !hasLeadingOwnLineComment(options.originalText, node);
const code = [
ifBreak([shouldAddStartLine ? line : "", "| "]),
join([line, "| "], printed),
];
if (pathNeedsParens(path, options)) {
return group([indent(code), softline]);
}
if (parent.type === "TupleTypeAnnotation" || parent.type === "TSTupleType") {
const elementTypes =
parent[
// TODO: Remove `types` when babel changes AST of `TupleTypeAnnotation`
parent.type === "TupleTypeAnnotation" && parent.types
? "types"
: "elementTypes"
];
if (elementTypes.length > 1) {
return group([
indent([ifBreak(["(", softline]), code]),
softline,
ifBreak(")"),
]);
}
}
return group(shouldIndent ? indent(code) : code);
}
/*
`FunctionTypeAnnotation` is ambiguous:
- `declare function foo(a: B): void;`
- `var A: (a: B) => void;`
*/
function isFlowArrowFunctionTypeAnnotation(path) {
const { node, parent } = path;
return (
node.type === "FunctionTypeAnnotation" &&
(isFlowObjectTypePropertyAFunction(parent) ||
!(
((parent.type === "ObjectTypeProperty" ||
parent.type === "ObjectTypeInternalSlot") &&
!parent.variance &&
!parent.optional &&
hasSameLocStart(parent, node)) ||
parent.type === "ObjectTypeCallProperty" ||
path.getParentNode(2)?.type === "DeclareFunction"
))
);
}
/*
- `TSFunctionType` (TypeScript)
- `TSCallSignatureDeclaration` (TypeScript)
- `TSConstructorType` (TypeScript)
- `TSConstructSignatureDeclaration` (TypeScript)
- `FunctionTypeAnnotation` (Flow)
*/
function printFunctionType(path, options, print) {
const { node } = path;
/** @type {Doc[]} */
const parts = [
// `TSConstructorType` only
printAbstractToken(path),
];
if (
node.type === "TSConstructorType" ||
node.type === "TSConstructSignatureDeclaration"
) {
parts.push("new ");
}
let parametersDoc = printFunctionParameters(
path,
print,
options,
/* expandArg */ false,
/* printTypeParams */ true,
);
const returnTypeDoc = [];
// `flow` doesn't wrap the `returnType` with `TypeAnnotation`, so the colon
// needs to be added separately.
if (node.type === "FunctionTypeAnnotation") {
returnTypeDoc.push(
isFlowArrowFunctionTypeAnnotation(path) ? " => " : ": ",
print("returnType"),
);
} else {
returnTypeDoc.push(
printTypeAnnotationProperty(
path,
print,
node.returnType ? "returnType" : "typeAnnotation",
),
);
}
if (shouldGroupFunctionParameters(node, returnTypeDoc)) {
parametersDoc = group(parametersDoc);
}
parts.push(parametersDoc, returnTypeDoc);
return group(parts);
}
/*
- `TSIndexedAccessType`(TypeScript)
- `IndexedAccessType`(flow)
- `OptionalIndexedAccessType`(flow)
*/
function printIndexedAccessType(path, options, print) {
return [
print("objectType"),
printOptionalToken(path),
"[",
print("indexType"),
"]",
];
}
/*
- `TSInferType`(TypeScript)
- `InferTypeAnnotation`(flow)
*/
function printInferType(path, options, print) {
return ["infer ", print("typeParameter")];
}
// `TSJSDocNullableType`, `TSJSDocNonNullableType`
function printJSDocType(path, print, token) {
const { node } = path;
return [
node.postfix ? "" : token,
printTypeAnnotationProperty(path, print),
node.postfix ? token : "",
];
}
/*
- `TSRestType`(TypeScript)
- `TupleTypeSpreadElement`(flow)
*/
function printRestType(path, options, print) {
const { node } = path;
return [
"...",
...(node.type === "TupleTypeSpreadElement" && node.label
? [print("label"), ": "]
: []),
print("typeAnnotation"),
];
}
/*
- `TSNamedTupleMember`(TypeScript)
- `TupleTypeLabeledElement`(flow)
*/
function printNamedTupleMember(path, options, print) {
const { node } = path;
return [
// `TupleTypeLabeledElement` only
node.variance ? print("variance") : "",
print("label"),
node.optional ? "?" : "",
": ",
print("elementType"),
];
}
/*
Normally the `(TS)TypeAnnotation` node starts with `:` token.
If we print `:` in parent node, `cursorNodeDiff` in `/src/main/core.js` will consider `:` is removed, cause cursor moves, see #12491.
Token *before* `(TS)TypeAnnotation.typeAnnotation` should be printed in `getTypeAnnotationFirstToken` function.
*/
const typeAnnotationNodesCheckedLeadingComments = new WeakSet();
function printTypeAnnotationProperty(
path,
print,
propertyName = "typeAnnotation",
) {
const {
node: { [propertyName]: typeAnnotation },
} = path;
if (!typeAnnotation) {
return "";
}
let shouldPrintLeadingSpace = false;
if (
typeAnnotation.type === "TSTypeAnnotation" ||
typeAnnotation.type === "TypeAnnotation"
) {
const firstToken = path.call(getTypeAnnotationFirstToken, propertyName);
if (
firstToken === "=>" ||
(firstToken === ":" &&
hasComment(typeAnnotation, CommentCheckFlags.Leading))
) {
shouldPrintLeadingSpace = true;
}
typeAnnotationNodesCheckedLeadingComments.add(typeAnnotation);
}
return shouldPrintLeadingSpace
? [" ", print(propertyName)]
: print(propertyName);
}
const getTypeAnnotationFirstToken = (path) => {
if (
// TypeScript
path.match(
(node) => node.type === "TSTypeAnnotation",
(node, key) =>
(key === "returnType" || key === "typeAnnotation") &&
(node.type === "TSFunctionType" || node.type === "TSConstructorType"),
)
) {
return "=>";
}
if (
// TypeScript
path.match(
(node) => node.type === "TSTypeAnnotation",
(node, key) =>
key === "typeAnnotation" &&
(node.type === "TSJSDocNullableType" ||
node.type === "TSJSDocNonNullableType" ||
node.type === "TSTypePredicate"),
) ||
/*
Flow
```js
declare function foo(): void;
^^^^^^^^ `TypeAnnotation`
```
*/
path.match(
(node) => node.type === "TypeAnnotation",
(node, key) => key === "typeAnnotation" && node.type === "Identifier",
(node, key) => key === "id" && node.type === "DeclareFunction",
) ||
/*
Flow
```js
declare hook foo(): void;
^^^^^^^^ `TypeAnnotation`
```
*/
path.match(
(node) => node.type === "TypeAnnotation",
(node, key) => key === "typeAnnotation" && node.type === "Identifier",
(node, key) => key === "id" && node.type === "DeclareHook",
) ||
/*
Flow
```js
type A = () => infer R extends string;
^^^^^^ `TypeAnnotation`
```
*/
path.match(
(node) => node.type === "TypeAnnotation",
(node, key) =>
key === "bound" &&
node.type === "TypeParameter" &&
node.usesExtendsBound,
)
) {
return "";
}
return ":";
};
/*
- `TSTypeAnnotation` (TypeScript)
- `TypeAnnotation` (Flow)
*/
function printTypeAnnotation(path, options, print) {
// We need print space before leading comments,
// `printTypeAnnotationProperty` is responsible for it.
/* c8 ignore start */
if (process.env.NODE_ENV !== "production") {
const { node } = path;
if (!typeAnnotationNodesCheckedLeadingComments.has(node)) {
throw Object.assign(
new Error(
`'${node.type}' should be printed by '${printTypeAnnotationProperty.name}' function.`,
),
{ parentNode: path.parent, propertyName: path.key },
);
}
}
/* c8 ignore stop */
const token = getTypeAnnotationFirstToken(path);
return token
? [token, " ", print("typeAnnotation")]
: print("typeAnnotation");
}
/*
- `TSArrayType`
- `ArrayTypeAnnotation`
*/
function printArrayType(print) {
return [print("elementType"), "[]"];
}
/*
- `TSTypeQuery` (TypeScript)
- `TypeofTypeAnnotation` (flow)
*/
function printTypeQuery({ node }, print) {
const argumentPropertyName =
node.type === "TSTypeQuery" ? "exprName" : "argument";
const typeArgsPropertyName =
// TODO: Use `typeArguments` only when babel align with TS.
node.type === "TypeofTypeAnnotation" || node.typeArguments
? "typeArguments"
: "typeParameters";
return ["typeof ", print(argumentPropertyName), print(typeArgsPropertyName)];
}
/*
- `TSTypePredicate` (TypeScript)
- `TypePredicate` (flow)
*/
function printTypePredicate(path, print) {
const { node } = path;
const prefix =
node.type === "TSTypePredicate" && node.asserts
? "asserts "
: node.type === "TypePredicate" && node.kind
? `${node.kind} `
: "";
return [
prefix,
print("parameterName"),
node.typeAnnotation
? [" is ", printTypeAnnotationProperty(path, print)]
: "",
];
}
export {
printArrayType,
printFunctionType,
printIndexedAccessType,
printInferType,
printIntersectionType,
printJSDocType,
printNamedTupleMember,
printOpaqueType,
printRestType,
printTypeAlias,
printTypeAnnotation,
printTypeAnnotationProperty,
printTypePredicate,
printTypeQuery,
printUnionType,
shouldHugType,
};
```
|
```c
/* Implementation of gettext(3) function.
This program is free software; you can redistribute it and/or modify
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef _LIBC
# define __need_NULL
# include <stddef.h>
#else
# ifdef STDC_HEADERS
# include <stdlib.h> /* Just for NULL. */
# else
# ifdef HAVE_STRING_H
# include <string.h>
# else
# define NULL ((void *) 0)
# endif
# endif
#endif
#ifdef _LIBC
# include <libintl.h>
#else
# include "libgettext.h"
#endif
/* @@ end of prolog @@ */
/* Names for the libintl functions are a problem. They must not clash
with existing names and they should follow ANSI C. But this source
code is also used in GNU C Library where the names have a __
prefix. So we have to make a difference here. */
#ifdef _LIBC
# define GETTEXT __gettext
# define DGETTEXT __dgettext
#else
# define GETTEXT gettext__
# define DGETTEXT dgettext__
#endif
/* Look up MSGID in the current default message catalog for the current
LC_MESSAGES locale. If not found, returns MSGID itself (the default
text). */
char *
GETTEXT (msgid)
const char *msgid;
{
return DGETTEXT (NULL, msgid);
}
#ifdef _LIBC
/* Alias for function name in GNU C Library. */
weak_alias (__gettext, gettext);
#endif
```
|
```javascript
ace.define("ace/mode/fsl_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("./text_highlight_rules").TextHighlightRules,s=function(){this.$rules={start:[{token:"punctuation.definition.comment.mn",regex:/\/\*/,push:[{token:"punctuation.definition.comment.mn",regex:/\*\//,next:"pop"},{defaultToken:"comment.block.fsl"}]},{token:"comment.line.fsl",regex:/\/\//,push:[{token:"comment.line.fsl",regex:/$/,next:"pop"},{defaultToken:"comment.line.fsl"}]},{token:"entity.name.function",regex:/\${/,push:[{token:"entity.name.function",regex:/}/,next:"pop"},{defaultToken:"keyword.other"}],comment:"js outcalls"},{token:"constant.numeric",regex:/[0-9]*\.[0-9]*\.[0-9]*/,comment:"semver"},{token:"constant.language.fslLanguage",regex:"(?:graph_layout|machine_name|machine_author|machine_license|machine_comment|machine_language|machine_version|machine_reference|npm_name|graph_layout|on_init|on_halt|on_end|on_terminate|on_finalize|on_transition|on_action|on_stochastic_action|on_legal|on_main|on_forced|on_validation|on_validation_failure|on_transition_refused|on_forced_transition_refused|on_action_refused|on_enter|on_exit|start_states|end_states|terminal_states|final_states|fsl_version)\\s*:"},{token:"keyword.control.transition.fslArrow",regex:/<->|<-|->|<=>|=>|<=|<~>|~>|<~|<-=>|<=->|<-~>|<~->|<=~>|<~=>/},{token:"constant.numeric.fslProbability",regex:/[0-9]+%/,comment:"edge probability annotation"},{token:"constant.character.fslAction",regex:/\'[^']*\'/,comment:"action annotation"},{token:"string.quoted.double.fslLabel.doublequoted",regex:/\"[^"]*\"/,comment:"fsl label annotation"},{token:"entity.name.tag.fslLabel.atom",regex:/[a-zA-Z0-9_.+&()#@!?,]/,comment:"fsl label annotation"}]},this.normalizeRules()};s.metaData={fileTypes:["fsl","fsl_state"],name:"FSL",scopeName:"source.fsl"},r.inherits(s,i),t.FSLHighlightRules=s}),ace.define("ace/mode/folding/cstyle",["require","exports","module","ace/lib/oop","ace/range","ace/mode/folding/fold_mode"],function(e,t,n){"use strict";var r=e("../../lib/oop"),i=e("../../range").Range,s=e("./fold_mode").FoldMode,o=t.FoldMode=function(e){e&&(this.foldingStartMarker=new RegExp(this.foldingStartMarker.source.replace(/\|[^|]*?$/,"|"+e.start)),this.foldingStopMarker=new RegExp(this.foldingStopMarker.source.replace(/\|[^|]*?$/,"|"+e.end)))};r.inherits(o,s),function(){this.foldingStartMarker=/([\{\[\(])[^\}\]\)]*$|^\s*(\/\*)/,this.foldingStopMarker=/^[^\[\{\(]*([\}\]\)])|^[\s\*]*(\*\/)/,this.singleLineBlockCommentRe=/^\s*(\/\*).*\*\/\s*$/,this.tripleStarBlockCommentRe=/^\s*(\/\*\*\*).*\*\/\s*$/,this.startRegionRe=/^\s*(\/\*|\/\/)#?region\b/,this._getFoldWidgetBase=this.getFoldWidget,this.getFoldWidget=function(e,t,n){var r=e.getLine(n);if(this.singleLineBlockCommentRe.test(r)&&!this.startRegionRe.test(r)&&!this.tripleStarBlockCommentRe.test(r))return"";var i=this._getFoldWidgetBase(e,t,n);return!i&&this.startRegionRe.test(r)?"start":i},this.getFoldWidgetRange=function(e,t,n,r){var i=e.getLine(n);if(this.startRegionRe.test(i))return this.getCommentRegionBlock(e,i,n);var s=i.match(this.foldingStartMarker);if(s){var o=s.index;if(s[1])return this.openingBracketBlock(e,s[1],n,o);var u=e.getCommentFoldRange(n,o+s[0].length,1);return u&&!u.isMultiLine()&&(r?u=this.getSectionRange(e,n):t!="all"&&(u=null)),u}if(t==="markbegin")return;var s=i.match(this.foldingStopMarker);if(s){var o=s.index+s[0].length;return s[1]?this.closingBracketBlock(e,s[1],n,o):e.getCommentFoldRange(n,o,-1)}},this.getSectionRange=function(e,t){var n=e.getLine(t),r=n.search(/\S/),s=t,o=n.length;t+=1;var u=t,a=e.getLength();while(++t<a){n=e.getLine(t);var f=n.search(/\S/);if(f===-1)continue;if(r>f)break;var l=this.getFoldWidgetRange(e,"all",t);if(l){if(l.start.row<=s)break;if(l.isMultiLine())t=l.end.row;else if(r==f)break}u=t}return new i(s,o,u,e.getLine(u).length)},this.getCommentRegionBlock=function(e,t,n){var r=t.search(/\s*$/),s=e.getLength(),o=n,u=/^\s*(?:\/\*|\/\/|--)#?(end)?region\b/,a=1;while(++n<s){t=e.getLine(n);var f=u.exec(t);if(!f)continue;f[1]?a--:a++;if(!a)break}var l=n;if(l>o)return new i(o,r,l,t.length)}}.call(o.prototype)}),ace.define("ace/mode/fsl",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/fsl_highlight_rules","ace/mode/folding/cstyle"],function(e,t,n){"use strict";var r=e("../lib/oop"),i=e("./text").Mode,s=e("./fsl_highlight_rules").FSLHighlightRules,o=e("./folding/cstyle").FoldMode,u=function(){this.HighlightRules=s,this.foldingRules=new o};r.inherits(u,i),function(){this.lineCommentStart="//",this.blockComment={start:"/*",end:"*/"},this.$id="ace/mode/fsl"}.call(u.prototype),t.Mode=u}); (function() {
ace.require(["ace/mode/fsl"], function(m) {
if (typeof module == "object" && typeof exports == "object" && module) {
module.exports = m;
}
});
})();
```
|
Tübän Öskebaş () is a rural locality (a selo) in Kukmara District, Tatarstan. The population was 424 as of 2010.
Tübän Öskebaş is located 27 km from Kukmara, district's administrative centre, and 167 km from Ԛazan, republic's capital, by road.
The earliest known record of the settlement dates from 1678.
There are 3 streets in the village.
References
External links
Rural localities in Kukmorsky District
|
```java
/*
*
* This file is part of LibreTorrent.
*
* LibreTorrent is free software: you can redistribute it and/or modify
* (at your option) any later version.
*
* LibreTorrent is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* along with LibreTorrent. If not, see <path_to_url
*/
package org.proninyaroslav.libretorrent.ui;
import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.Settings;
import androidx.activity.ComponentActivity;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat;
import org.proninyaroslav.libretorrent.core.RepositoryHelper;
import org.proninyaroslav.libretorrent.core.settings.SettingsRepository;
import org.proninyaroslav.libretorrent.core.utils.Utils;
import java.util.ArrayList;
public class PermissionManager {
private ActivityResultLauncher<Intent> manageExternalStoragePermission;
private ActivityResultLauncher<String[]> permissions;
private final Context appContext;
private SettingsRepository pref;
private boolean hasManageExternalStoragePermission;
public PermissionManager(
@NonNull ComponentActivity activity,
@NonNull Callback callback
) {
appContext = activity.getApplicationContext();
pref = RepositoryHelper.getSettingsRepository(appContext);
// MANAGE_EXTERNAL_STORAGE is disabled for the Google Play version
// so we need to check before requesting permission
hasManageExternalStoragePermission = Utils.hasManageExternalStoragePermission(appContext);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && hasManageExternalStoragePermission) {
manageExternalStoragePermission = activity.registerForActivityResult(
new ActivityResultContracts.StartActivityForResult(),
result -> callback.onStorageResult(
checkStoragePermissions(),
pref.askManageAllFilesPermission()
)
);
}
permissions = activity.registerForActivityResult(
new ActivityResultContracts.RequestMultiplePermissions(),
result -> {
Boolean storageResult = result.get(Manifest.permission.WRITE_EXTERNAL_STORAGE);
Boolean notificationsResult;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
notificationsResult = result.get(Manifest.permission.POST_NOTIFICATIONS);
} else {
notificationsResult = true;
}
if (storageResult != null) {
callback.onStorageResult(
storageResult,
Utils.shouldRequestStoragePermission(activity)
);
}
if (notificationsResult != null) {
callback.onNotificationResult(
notificationsResult,
pref.askNotificationPermission()
);
}
}
);
}
public void requestPermissions() {
ArrayList<String> permissionsList = new ArrayList<>();
if (!checkStoragePermissions()) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && hasManageExternalStoragePermission) {
if (pref.askManageAllFilesPermission()) {
var uri = Uri.fromParts("package", appContext.getPackageName(), null);
var i = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION)
.setData(uri);
manageExternalStoragePermission.launch(i);
}
} else {
permissionsList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
}
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && pref.askNotificationPermission() && !checkNotificationsPermissions()) {
permissionsList.add(Manifest.permission.POST_NOTIFICATIONS);
}
permissions.launch(permissionsList.toArray(new String[0]));
}
public void setDoNotAskStorage(boolean doNotAsk) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
pref.askManageAllFilesPermission(!doNotAsk);
}
}
public void setDoNotAskNotifications(boolean doNotAsk) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
pref.askNotificationPermission(!doNotAsk);
}
}
public boolean checkStoragePermissions() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && hasManageExternalStoragePermission) {
return Environment.isExternalStorageManager();
} else {
return ContextCompat.checkSelfPermission(appContext,
Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
}
}
public boolean checkNotificationsPermissions() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
return ContextCompat.checkSelfPermission(appContext,
Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED;
} else {
return false;
}
}
public boolean checkPermissions() {
return checkStoragePermissions() && checkNotificationsPermissions();
}
public interface Callback {
void onStorageResult(boolean isGranted, boolean shouldRequestStoragePermission);
void onNotificationResult(boolean isGranted, boolean shouldRequestNotificationPermission);
}
}
```
|
```c++
// sol2
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define CATCH_CONFIG_RUNNER
#include <catch2/catch_all.hpp>
int main(int argc, char* argv[]) {
int result = Catch::Session().run(argc, argv);
return result;
}
```
|
```makefile
#/
# @license Apache-2.0
#
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#/
# RULES #
#/
# Runs Python benchmarks consecutively.
#
# ## Notes
#
# - The recipe assumes that benchmark files can be run via Python.
# - This rule is useful when wanting to glob for Python benchmark files (e.g., run all Python benchmarks for a particular package).
#
#
# @param {string} [BENCHMARKS_FILTER] - file path pattern (e.g., `.*/math/base/special/digamma/.*`)
#
# @example
# make benchmark-python
#
# @example
# make benchmark-python BENCHMARKS_FILTER=".*/math/base/special/digamma/.*"
#/
benchmark-python:
$(QUIET) $(FIND_PYTHON_BENCHMARKS_CMD) | grep '^[\/]\|^[a-zA-Z]:[/\]' | while read -r file; do \
echo ""; \
echo "Running benchmark: $$file"; \
$(PYTHON) $$file || exit 1; \
done
.PHONY: benchmark-python
#/
# Runs a specified list of Python benchmarks consecutively.
#
# ## Notes
#
# - The recipe assumes that benchmark files can be run via Python.
# - This rule is useful when wanting to run a list of Python benchmark files generated by some other command (e.g., a list of changed Python benchmark files obtained via `git diff`).
#
#
# @param {string} FILES - list of Python benchmark file paths
#
# @example
# make benchmark-python-files FILES='/foo/benchmark.py /bar/benchmark.py'
#/
benchmark-python-files:
$(QUIET) for file in $(FILES); do \
echo ""; \
echo "Running benchmark: $$file"; \
$(PYTHON) $$file || exit 1; \
done
.PHONY: benchmark-python-files
```
|
```smalltalk
// ==========================================================================
// Squidex Headless CMS
// ==========================================================================
// ==========================================================================
using Squidex.Domain.Apps.Core.Apps;
using Squidex.Domain.Apps.Core.Assets;
using Squidex.Domain.Apps.Core.Contents;
using Squidex.Domain.Apps.Core.Rules;
using Squidex.Domain.Apps.Core.Schemas;
using Squidex.Domain.Apps.Entities.Apps.DomainObject;
using Squidex.Domain.Apps.Entities.Assets.DomainObject;
using Squidex.Domain.Apps.Entities.Contents.DomainObject;
using Squidex.Domain.Apps.Entities.Rules.DomainObject;
using Squidex.Domain.Apps.Entities.Schemas.DomainObject;
using Squidex.Infrastructure.Commands;
using Squidex.Infrastructure.EventSourcing;
namespace Migrations;
public static class RebuilderExtensions
{
private const double AllowedErrorRate = 0.02;
public static Task RebuildAppsAsync(this Rebuilder rebuilder, int batchSize,
CancellationToken ct = default)
{
var streamFilter = StreamFilter.Prefix("app-");
return rebuilder.RebuildAsync<AppDomainObject, App>(streamFilter, batchSize, AllowedErrorRate, ct);
}
public static Task RebuildSchemasAsync(this Rebuilder rebuilder, int batchSize,
CancellationToken ct = default)
{
var streamFilter = StreamFilter.Prefix("schema-");
return rebuilder.RebuildAsync<SchemaDomainObject, Schema>(streamFilter, batchSize, AllowedErrorRate, ct);
}
public static Task RebuildRulesAsync(this Rebuilder rebuilder, int batchSize,
CancellationToken ct = default)
{
var streamFilter = StreamFilter.Prefix("rule-");
return rebuilder.RebuildAsync<RuleDomainObject, Rule>(streamFilter, batchSize, AllowedErrorRate, ct);
}
public static Task RebuildAssetsAsync(this Rebuilder rebuilder, int batchSize,
CancellationToken ct = default)
{
var streamFilter = StreamFilter.Prefix("asset-");
return rebuilder.RebuildAsync<AssetDomainObject, Asset>(streamFilter, batchSize, AllowedErrorRate, ct);
}
public static Task RebuildAssetFoldersAsync(this Rebuilder rebuilder, int batchSize,
CancellationToken ct = default)
{
var streamFilter = StreamFilter.Prefix("assetFolder-");
return rebuilder.RebuildAsync<AssetFolderDomainObject, AssetFolder>(streamFilter, batchSize, AllowedErrorRate, ct);
}
public static Task RebuildContentAsync(this Rebuilder rebuilder, int batchSize,
CancellationToken ct = default)
{
var streamFilter = StreamFilter.Prefix("content-");
return rebuilder.RebuildAsync<ContentDomainObject, WriteContent>(streamFilter, batchSize, AllowedErrorRate, ct);
}
}
```
|
The Harris Building, also known as the Laird, Schober & Company Building, is an historic factory building which is located in the Logan Square neighborhood of Philadelphia, Pennsylvania.
It was added to the National Register of Historic Places in 2001.
History and architectural features
Built between 1914 and 1915, this historic factory building is an eight-story, "L"-shaped, reinforced concrete building, which is clad in brick and has terra cotta details. From 1914 to 1942, it housed Laird, Schober & Company, a manufacturer of women's, children's, and misses' shoes. It then housed a clothing manufacturer until 1985.
It was added to the National Register of Historic Places in 2001.
References
Industrial buildings and structures on the National Register of Historic Places in Philadelphia
Industrial buildings completed in 1915
Logan Square, Philadelphia
|
Heqin, also known as marriage alliance, refers to the historical practice of Chinese monarchs marrying princesses—usually members of minor branches of the ruling family—to rulers of neighboring states. It was often adopted as an appeasement strategy with an enemy state that was too powerful to defeat on the battlefield. The policy was not always effective. It implied an equal diplomatic status between the two monarchs. As a result, it was controversial and had many critics.
Lou Jing (, later granted the imperial surname Liu 劉), the architect of the policy, proposed granting the eldest daughter of Emperor Gaozu of Han to the Modu Chanyu of the Xiongnu. His proposal was adopted and implemented with a treaty in 198BC, following the Battle of Baideng two years prior. Wang Zhaojun, of the Han dynasty, and Princess Wencheng, of the Tang dynasty, are among the most famous heqin princesses.
The 20th-century scholar Wang Tonglin praised heqin for facilitating the "melting of races" in China.
Han dynasty
There were a total of fifteen instances of heqin marriage alliances during the Han dynasty.
The Han dynasty sent random unrelated commoner women falsely labeled as "princesses" and members of the Han imperial family multiple times when they were practicing Heqin marriage alliances with the Xiongnu in order to avoid sending the emperor's daughters.
200BC: Emperor Gaozu of Han marries a Han "princess" to Xiongnu chieftain Modu Chanyu. This is the first recorded incidence of heqin in Chinese history.
192BC: Emperor Hui of Han marries another Han "princess" to Xiongnu chieftain Modu Chanyu.
176BC: Emperor Wen of Han marries a third Han "princess" to Xiongnu chieftain Modu Chanyu.
174BC: Emperor Wen of Han marries a Han "princess" to Xiongnu chieftain Laoshang Chanyu. She brings a Yan eunuch named Zhonghang Yue with her to be her tutor.
162BC: Emperor Wen of Han marries another Han "princess" to Xiongnu chieftain Laoshang Chanyu.
160BC: Emperor Wen of Han marries a Han "princess" to Xiongnu chieftain Gunchen Chanyu.
156BC: Emperor Jing of Han marries another Han "princess" to Xiongnu chieftain Gunchen Chanyu.
155BC: Emperor Jing of Han marries a third Han "princess" to Xiongnu chieftain Gunchen Chanyu.
152BC: Emperor Jing of Han marries a fourth Han "princess" to Xiongnu chieftain Gunchen Chanyu.
140BC: Emperor Wu of Han marries a Han "princess" to Xiongnu chieftain Gunchen Chanyu.
108BC: Emperor Wu of Han marries Liu Xijun (刘细君 130–101 BC), daughter of Liu Jian (刘建), Prince of Jiangdu (江都王 d. 121 BC), granddaughter of Prince Yi of Jiangdu, to Liejiaomi, King of Wusun.
103BC: Emperor Wu of Han marries Liu Jieyou (刘解忧 121–49 BC) to King Junxumi of Wusun (Liejiaomi's grandson). After Junxumi's death in 93BC, Princess Jieyou, in accordance with Wusun tradition, married his successor (and younger brother), King Wengguimi. After Wengguimi's death in 60BC, Princess Jieyou again remarried his successor King Nimi (son of Junximi and a Xiongnu princess).
33BC: Emperor Yuan of Han marries Wang Zhaojun (王昭君 52 BC – 15), a lady of the imperial harem, to Xiongnu chieftain Huhanye. After Huhanye's death in 31BC, she remarried Huhanye's successor (his son by his first wife and thus her stepson) Fuzhuleiruodi Chanyu.
Xiongnu
The Xiongnu practiced marriage alliances with Han dynasty officers and officials by marrying off daughters of the Chanyu (the Xiongnu ruler) to Han people who joined the Xiongnu and Xiongnu in Han service. The daughter of the Laoshang Chanyu (and older sister of Junchen Chanyu and Yizhixie Chanyu) was married to the Xiongnu General Zhao Xin, the Marquis of Xi who was serving the Han dynasty. The daughter of the Qiedihou Chanyu was married to the Han general Li Ling after he surrendered and defected. The Yenisei Kirghiz Khagans claimed descent from Li Ling. Another Han general who defected to the Xiongnu was Li Guangli who also married a daughter of the Hulugu Chanyu. The Han diplomat Su Wu married a Xiongnu woman given by Li Ling when he was arrested and taken captive. The Han explorer Zhang Qian married a Xiongnu woman and had a child with her when he was taken captive by the Xiongnu. The Emperor Wu of Han dispatched Zhang Qian to explore the Western Regions and to form an alliance with the Yuezhi people in order to combat the Xiongnu. During this time Zhang married a Xiongnu wife, who bore him a son, and gained the trust of the Xiongnu leader.
The Yenisei Kyrgyz khagans of the Yenisei Kyrgyz Khaganate claimed descent from the Han general Li Ling, grandson of the famous general Li Guang. Li Ling was captured by the Xiongnu and defected in the first century BCE. And since the Tang imperial Li family also claimed descent from Li Guang, the Kirghiz Khagan was therefore recognized as a member of the Tang imperial family. This relationship soothed the relationship when Kyrgyz khagan Are (阿熱) invaded Uyghur Khaganate and put Qasar Qaghan to the sword. The news brought to Chang'an by Kyrgyz ambassador Zhuwu Hesu (註吾合素).
Kingdom of Khotan
The Cao family of ethnic Han descent that ruled the Guiyi Circuit established marriage alliances with the Saka Kingdom of Khotan, with both the Cao rulers marrying Khotanese princesses and with Cao princesses marrying Khotan rulers. A Khotan princess who was the daughter of the King of Khotan married Cao Yanlu.
Sixteen Kingdoms
During the Sixteen Kingdoms period, there were a total of six recorded instances of heqin marriage. Heqin marriage alliances during the Sixteen Kingdoms period differed from those practiced during the Han dynasty in two main ways. First, they involved "real" princesses (i.e. daughters of emperors or rulers). Second, unlike during the Han dynasty, when most heqin marriages were aimed at establishing peace with foreign nations, heqin marriages during the Sixteen Kingdoms period were made primarily to settle rivalries and maintain a balance of power between the various states in China at the time.
Fu Jian (337–385), Emperor Xuanzhao of Former Qin, married one of his daughters to Yang Ding, ruler of the state of Chouchi.
Fu Deng, Emperor Gao of Former Qin, married his younger sister, Princess Dongping (东平公主) to Qifu Gangui, Prince of Western Qi.
441: Feng Ba, Emperor Wencheng of Northern Yan, married his daughter, Princess Lelang (乐浪公主), to Yujiulü Hulü, Khan Aidougai of Rouran.
415: Yao Xing, Emperor Wenhuan of Later Qin, married his daughter, Princess Xiping (西平公主), to Emperor Mingyuan of Northern Wei. Because she was unable to forge a golden statue with her own hands, she was never formally empress, but was nevertheless recognized and respected as Emperor Mingyuan's wife, Consort Yao.
Qifu Chipan, Prince Wenzhao of Western Qin, married his daughter, Princess Xingping (兴平公主), to Juqu Mengxun, Prince of Northern Liang's son Juqu Xingguo.
433: Juqu Mengxun, Prince of Northern Liang, marries his daughter, Princess Xingping (兴平公主), to Emperor Taiwu of Northern Wei. She became Emperor Taiwu's concubine.
Northern and Southern dynasties
During the Northern and Southern dynasties period, China was divided into many rival states. A complicated system of rivalries and vassalage existed. Heqin marriage was employed as a method to maintain a balance of power or to solidify alliances between states.
During the Northern and Southern dynasties, there were five instances of heqin marriage.
428: Emperor Mingyuan of Northern Wei marries his daughter, Princess Shiping (始平公主), to Helian Chang, Emperor of Xia.
437: Emperor Mingyuan of Northern Wei marries his daughter, Princess Wuwei (武威公主), to Juqu Mujian, Prince Ai of Hexi, last ruler of the state of Northern Liang, whence she is known as Princess Tuoba.
Princess Lanling (兰陵公主), a princess of the imperial family of Northern Wei, married the Khagan of the Rouran Khaganate, Yujiulü Anagui.
Princess Qianjin (千金公主), daughter of Yuwen Zhao, Prince of Zhao (赵王宇文招) and a member of the imperial family of Northern Zhou, married Ishbara, Khagan of the Eastern Turkic Khaganate.
582: Emperor Ming of Western Liang marries his daughter, Princess Xiao, to Yang Guang, Prince of Jin, the second son Emperor Ming's overlord, Emperor Wen of Sui. She is known as Empress Xiao of Sui after his accession to the throne as Emperor Yang of Sui.
Northern Wei
The Tuoba imperial family of the Xianbei-led Northern Wei dynasty started to arrange for ethnic Han elites to marry daughters of the imperial family in the 480s. More than fifty percent of Tuoba Xianbei princesses of the Northern Wei were married to southern Han men from the imperial families and aristocrats from southern China of the Southern dynasties who defected and moved north to join the Northern Wei. Some exiled royalty of Han descent fled from southern China and defected to the Northern Wei. Several daughters of the Xianbei Emperor Xiaowen of Northern Wei were married to ethnic Han elites, the Liu Song royal Liu Hui 刘辉, married Princess Lanling 蘭陵公主 of the Northern Wei, Princess Huayang 華陽公主 to Sima Fei 司馬朏, a descendant of Jin dynasty (266–420) royalty, Princess Jinan 濟南公主 to Lu Daoqian 盧道虔, Princess Nanyang 南阳长公主 to Xiao Baoyin 萧宝夤, a member of Southern Qi royalty. Emperor Xiaozhuang of Northern Wei's sisters, the Shouyang Princess was wedded to the Liang dynasty ruler Emperor Wu of Liang's son Xiao Zong 蕭綜. One of Emperor Xiaowu of Northern Wei's sister was married to Zhang Huan, an ethnic Han, according to the Book of Zhou. His name is given as Zhang Xin in the Book of Northern Qi and History of the Northern Dynasties which mention his marriage to a Xianbei princess of Wei. His personal name was changed due to a naming taboo on the emperor's name. He was the son of Zhang Qiong.
When the Eastern Jin dynasty ended Northern Wei received the Jin prince Sima Chuzhi (司馬楚之) as a refugee. A Northern Wei Princess married Sima Chuzhi, giving birth to Sima Jinlong. Northern Liang Xiongnu King Juqu Mujian's daughter married Sima Jinlong.
Rouran
The Rouran Khaganate arranged for one of their princesses, Khagan Yujiulü Anagui's daughter Princess Ruru 蠕蠕公主 to be married to the ethnic Han regent Gao Huan of the Eastern Wei.
Gaochang
The Kingdom of Gaochang was made out of ethnic Han colonists and ruled by the Han people Qu family, which originated from Gansu. Jincheng commandery (金城 in Lanzhou), district of Yuzhong (榆中) was the home of the Qu Jia. The Qu family was linked by marriage alliances to the Turks, with a Turk being the grandmother of King Qu Boya's.
Sui dynasty
With the establishment of the Sui dynasty in 581, much of China proper was once again unified under one dynasty. Heqin marriage during the Sui dynasty therefore returned to its original purpose of trying to appease barbarian tribes surrounding the Sui. There were a total of seven instances of heqin marriage during the Sui dynasty.
597: Emperor Wen of Sui marries Princess Anyi (安义公主), a Sui "princess", to Yami Qaghan, Khagan of the Eastern Turkic Khaganate. She was assassinated by Yung Yu- lu in 599
599: Emperor Wen of Sui marries another Sui princess, Princess Yicheng (义成公主), the daughter of a Sui imperial clansman, to Yami, Khagan of the Eastern Turkic Khaganate. After his death in 609, Princess Yicheng, in accordance with the Göktürk custom of levirate marriage, remarried to Yami Qaghan's successor and son (by another wife), Shibi Qaghan. After Shibi Qaghan's death in 619, Princess Yicheng again remarried to Shibi Qaghan's successor and younger brother, Chuluo. After the khagan's death in 621, Princess Yicheng remarried for the fourth and final time to his successor and younger brother, Illig Qaghan, who revolted against Tang China and was captured and killed in 630
Emperor Yang of Sui married Princess Xinyi (信义公主), a Sui "princess", to Heshana Khan, Khagan of the Western Turkish Khaganate.
Emperor Yang of Sui married his youngest daughter, Princess Huainan (淮南公主), to the new heir, Shibi's eldest son, Tuli.
596: Emperor Wen of Sui marries Princess Guanghua (光化公主), a Sui "princess", to Murong Shifu, khagan of Tuyuhun. After Murong Shifu's assassination in 597, Princess Guanghua remarried Murong Shifu's successor and younger brother, Murong Fuyun.
Emperor Yang of Sui married a Sui "princess" to Qu Boya, ruler of the oasis city of Gaochang in the Taklamakan Desert.
Tang dynasty
During the Tang dynasty, heqin marriage alliances were primarily aimed at the Tuyuhun, the Tibetan Empire, the Khitans and the allied Kumo Xi, the Uyghur Khaganate, and Nanzhao.
There were a total of twenty-one instances of heqin marriage alliances during the Tang dynasty, including:
640: Emperor Taizong of Tang marries Princess Honghua (弘化公主) to Murong Nuohebo, Khan of Tuyuhun.
641: Emperor Taizong of Tang marries Princess Wencheng to Emperor Songtsän Gampo of Tibet.
642: Emperor Taizong proposed the marriage of his fifteenth daughter, Princess Xinxing (新兴公主), to Zhenzhu Khan, Khan of Xueyantuo. The heqin was called off.
664: Emperor Gaozong of Tang marries Lady Jincheng (金城县主), the third daughter of Li Dao'en, Prince of Guiji (会稽郡王李道恩), to Prince Sudumomo of Tuyuhun (吐谷浑王子苏度摸末).
664: Emperor Gaozong marries Lady Jinming (金明县主), the daughter of a Tang imperial clansman, to Prince Talumomo of Tuyuhun (吐谷浑王子闼卢摸末).
698: A daughter of Qapaghan, Khagan of the Second Eastern Turkic Khaganate marries Wu Zetian's great-nephew Wu Chengsi, Prince of Huaiyang (淮阳王武延秀).
703: A daughter of Qapaghan Khagan marries Crown Prince Li Dan's eldest son Li Chengqi, Prince of Song.
709: Empress Wu Zetian marries her great-granddaughter Princess Jincheng (金城公主), the daughter of her grandson Li Shouli, Prince of Bin, to Emperor Me Agtsom of Tibet
712: Emperor Ruizong of Tang marries his granddaughter, Princess Jinshan (金山公主), the daughter of his son Li Chengqi, to Qapaghan Khagan
717: Emperor Xuanzong of Tang marries Princess Yongle (永乐公主), the daughter of Yang Yuansi (杨元嗣) and a daughter of Li Xu, Prince of Dongping (东平王李续, son of Li Shen, Prince of Ji, the seventeenth son of Emperor Taizong), to Li Shihuo (李失活), leader of the Khitans.
717: Princess Jianghe (交河公主), the daughter of Ashina Nahuaidao, 10th Khagan of the Western Turkic Khaganate, marries Sulu Khan, Khagan of Turgesh.
722: Emperor Xuanzong of Tang marries Princess Yanjun (燕郡公主) (surname Murong (慕容)), a Tang "princess", to Khitan prince Li Yuyu (李郁于).
726: Emperor Xuanzong marries his niece, Princess Donghua (东华公主, surname Chen 陈), to Khitan prince Li Shaogu (李邵固).
726: Emperor Xuanzong marries Princess Dongguang (东光公主), the daughter of Emperor Xuanzong's first cousin Li Jijiang, Princess Cheng'an (成安公主李季姜 eighth daughter of Emperor Zhongzong of Tang) and Wei Jie (韦捷), to Li Lusu (李鲁苏), ruler of Kumo Xi.
744: Emperor Xuanzong marries Princess Heyi (和义公主), a daughter of Li Can, Magistrate of Gaocheng (告城县令李参), to Axilan Dagan (阿悉烂达干), King of Ningyuan (宁远国王) in the Fergana Valley.
745: Emperor Xuanzong marries his granddaughter, Princess Jingle (静乐公主, daughter of his fifteenth daughter Princess Xincheng 信成公主 and Dugu Ming 独孤明), to Khitan prince Li Huaixiu (李怀秀).
745: Emperor Xuanzong marries Princess Yifang (宜芳公主), daughter of Princess Changning (长宁公主, daughter of Emperor Zhongzong of Tang) and Yang Shenjiao (杨慎交), to Khitan prince Li Yanchong (李延宠)
756: Emperor Suzong of Tang marries his daughter, Princess Ninguo to Bayanchur, Khagan of the Uyghur Khaganate. In exchange, Princess Pijia (毗伽公主), daughter of Bayanchur, marries Li Chengcai (李承采), Prince of Dunhuang (敦煌王李承采), son of Li Shouli, Prince of Bin.
Liao, Song, Jin dynasties
Song dynasty
The Khitan-led Liao dynasty asked for a Song princess to marry the Liao emperor in the negotiations leading up to the Chanyuan Treaty but the Song dynasty refused to give a princess. The Jurchen-led Jin dynasty later rebelled against the Liao dynasty, sacked and destroyed the Liao supreme capital and burned the ancestral tombs of the Liao emperors. The Emperor Tianzuo of Liao was executed by the Jurchens during a polo match. Liao imperial princesses from the Yelü family and Xiao family were also distributed to Jin princes as concubine. Wanyan Liang married the Khitan women Lady Xiao (蕭氏), Consort Chen (宸妃), Lady Yelü (耶律氏), Consort Li (麗妃), Lady Yelü (耶律氏), Consort Rou (柔妃) and Lady Yelü (耶律氏), Zhaoyuan (昭媛).
The Jin dynasty then attacked the Northern Song dynasty in the Jingkang incident and seized a large number of the Song imperial family. Song princesses were married off to Jin princes such as Emperor Xizong of Jin. The Song male princes who were captured were given ethnic Khitan women to marry from the Liao dynasty palace by the Jin, who had also defeated and conquered the Liao. The original Han wives of the Song princes were confiscated and replaced with Khitan ones. One of the Emperor Huizong of Song's sons was given a Khitan consort from the Liao palace, and another one of his sons was given a Khitan princess by the Jin at the Jin supreme capital. The Jurchens continued to give new wives to the captured Song royals, the grandsons and sons of the Emperor Huizong of Song after they took away their original ethnic Han wives. The Jin told the Song royals that they were fortunate because the Liao royals were being treated much worse by the Jin than the Song royals, Jin soldiers were given the children of the Emperor Tianzuo of Liao as gifts while the Song emperor was allowed to keep his children while he was in captivity.
Liao dynasty
The Liao dynasty arranged for women from the consort Xiao clan to marry members of the Han 韓 clan of ethnic Han descent, which originated in Jizhou 冀州 before being abducted by the Liao and becoming part of the ethnic Han elites of the Liao.
The Geng family of Han descent intermarried with the Khitans and the Han 韓 clan provided two of their women as wives to Geng Yanyi and the second one was the mother of Geng Zhixin. Empress Rende's sister, a member of the Xiao clan, was the mother of Han Chinese General Geng Yanyi.
Han Derang (Yelü Longyun) was the father of Queen dowager of the State of Chen, who was the wife of General Geng Yanyi and buried with him in his tomb in Zhaoyang in Liaoning. His wife was also known as "Madame Han". The Geng's tomb is located in Liaoning at Guyingzi in Chaoying.
Ganzhou Uyghur Kingdom
The Cao family of ethnic Han descent that ruled the Guiyi Circuit established marriage alliances with the Uighurs of the Ganzhou Kingdom, with both the Cao rulers marrying Uighur princesses and with Cao princesses marrying Uighur rulers. The Ganzhou Uighur Khagan's daughter was married to Cao Yijin in 916.
Yuan dynasty
The Jin emperor Wanyan Yongji's daughter Princess Qiguo was married to Genghis Khan in exchange for relieving the Mongol siege upon Zhongdu (Beijing) in the Mongol conquest of the Jin dynasty.
The Emperor Gong of Song surrendered to the Yuan dynasty in 1276 and was married off to an ethnic Mongol princess of the imperial Borjigin family of the Yuan dynasty. Zhao Xian had one son with the Borjigin woman, Zhao Wanpu. Zhao Xian's son Zhao Wanpu was kept alive by the Yuan because of his mother's Borjigin ancestry even after Zhao Xian was ordered killed by the Emperor Yingzong of Yuan. Instead Zhao Wanpu was only moved and exiled. The outbreak of the Song loyalist Red Turban Rebellion in Henan led to a recommendation that Zhao Wanpu should be transferred somewhere else by an Imperial Censor in 1352. The Yuan did not want the ethnic Han rebels to get their hands on Zhao Wanpu so no one was permitted to see him and Zhao Wanpu's family and himself were exiled to Shazhou near the border by the Yuan emperor. Paul Pelliot and John Andrew Boyle commented on Rashid-al-Din Hamadani's chapter The Successors of Genghis Khan in his work Jami' al-tawarikh, identified references by Rashid al-Din to Zhao Xian in his book where he mentions a Chinese ruler who was an "emir" and son-in-law to the Qan (Khan) after being removed from his throne by the Mongols and he is also called "Monarch of Song", or "Suju" (宋主; Songzhu) in the book.
The King of Dali Duan Gong was married to the Borjigin princess Agai, daughter of the Yuan dynasty Prince of Liang, Basalawarmi. They had a son and a daughter, Duan Sengnu. their children were also called Duan Qiangna and Duan Bao. Duan Sengnu raised Duan Bao to take revenge against Basalawarmi for the killing of Duan Gong. A play was made based on these events. According to Yuan documents, the Duan family were originally ethnic Han from Wuwei commandery, Gansu. Other Duan families also originated from Wuwei.
Ming dynasty
The Oirat leader Esen Taishi captured the Zhengtong Emperor of the Ming dynasty. Esen Taishi tried to force the Zhengtong Emperor to marry Esen's sister in a heqin marriage and then placing him back in Beijing with his new wife. The emperor rejected the marriage proposal.
A Mongol account in the Altan Tobchi said that Zhengtong Emperor had a son with an ethnic Mongol woman he married while he was prisoner.
A Mongol girl was given in marriage by the Gün-bilig-mergen Mongol Ordos leader Rinong (Jinong) to the ethnic Han officer of the Datong Army Wang Duo's (王鐸) son Wang San (王三) because Rinong wanted to hold on to Wang San and make him stay with the Mongols. The Ming arrested and executed Wang San in 1544 because Mongol soldiers were being guided by Wang San. Builders, carpenters, officers, and important prisoners such as the Ming Zhengtong Emperor often ethnic received Mongol wives.
Qing dynasty
In the total span of the Qing dynasty, the number of ethnic Mongol grooms of Qing princesses was the largest. More than 58 percent of imperial sons-in-law were Mongols. A total of 32 princesses married Mongols but the majority of these were in the early Qing like Emperor Hong Taiji who married off 12 of his daughters to ethnic Mongol elites, when the Qing needed military support. In the early period of Qing, a large amount of intermarriage between the two groups happened, and the Qing rulers used this tie to gain the military support from the Mongol tribes. The marriage also benefited the Qing dynasty in expanding its empire into the Mongolian Plateau and further west into Inner Asia. The marriage between ethnic Manchu princesses and ethnic Mongol princes continued to the end of Qing dynasty, although becoming less prominent after the 18th century due to the decline of the Mongols' political and military influence within the empire and the Qing after 1770 totally ceased marrying princesses off to Northern and Western Mongols, only marrying them off to princes from the southern Mongols who voluntarily surrendered to them before the establishment of the Qing, who numbered 7 tribes and 13 banners since the locations they inhabited were vital to Qing security unlike the steppes of the Northern and Western Mongols since the wars between the Zunghars and Khalkhas was over. During the Qianlong reign in 1751 and Jiaqing reign in 1801, the Qing emperors deliberately issued decrees eliminating Mongols from potential grooms of Qing princesses and started replacing them with majority Manchu grooms. The Qing at this time no longer needed the support of Mongols and started marrying off their daughters to majority Manchu grooms instead of Mongols.
Ethnic Han generals who defected to the Qing early on were sometimes married to Qing princesses due to the desperate need of the Qing for military allies at that time and their use of marrying their women off to get them, although this is less frequent than the case where Aisin Gioro women married to ethnic Mongol aristocrats or other Manchu elites. Unlike the marriage between Manchus and southern Mongols that lasted throughout the Qing dynasty, the marriages between Qing princesses and ethnic Han generals ceased before 1750 as Qing rule was consolidated by then.
The Manchu imperial Aisin Gioro clan practiced marriage alliances with Ming generals of Han descent and Mongol princes. Aisin Gioro women were married to ethnic Han generals who defected to the Qing side during the Transition from Ming to Qing. The Later Jin leader Nurhaci married one of his granddaughters, a daughter of Abatai, to the Ming general Li Yongfang, the ancestor of Li Shiyao (李侍堯). The offspring of Li received the "Third Class Viscount" () title after he surrendered Fushun in Liaoning to the Manchu in 1618. A mass marriage of Han officers and officials to Manchu women numbering 1,000 couples was arranged by Prince Yoto 岳托 (Prince Keqin) and Hong Taiji in 1632 to promote harmony between the two ethnic groups. Aisin Gioro women were married to the sons of the Han generals Sun Sike (孫思克), Geng Jimao, Shang Kexi, and Wu Sangui.
The "Dolo efu" 和碩額駙 rank was given to husbands of Qing princesses. Geng Zhongming, a Han bannerman, was awarded the title of Prince Jingnan, and his son Geng Jingmao managed to have both his sons Geng Jingzhong and Geng Zhaozhong 耿昭忠 become court attendants under the Shunzhi Emperor and marry Aisin Gioro women, with Prince Abatai's granddaughter marrying Geng Zhaozhong 耿昭忠 and Haoge's (a son of Hong Taiji) daughter marrying Geng Jingzhong. A daughter 和硕柔嘉公主 of the Manchu Aisin Gioro Prince Yolo 岳樂 (Prince An) was wedded to Geng Juzhong who was another son of Geng Jingmao.
The 4th daughter of Kangxi (和硕悫靖公主) was wedded to the son (孫承恩) of Sun Sike (孫思克), an ethnic Han.
Imperial Duke Who Assists the State (宗室輔國公) Aisin Gioro Suyan's (蘇燕) daughter was married to Han Banner general Nian Gengyao. She was Manchu Prince Ajige's great-great-granddaughter.
Manchu Prince Aisin Gioro Yuntang's fourth daughter married the Han Bannerman Zhao Shiyang (趙世揚) in 1721. Manchu Prince Aisin Gioro Yunsi's first daughter married the Han Bannerman Sun Wufu (孫五福) in July/August 1724. Manchu Prince Aisin Gioro Yunzhi, Prince Zhi's second daughter married the Han Bannerman Li Shu'ao (李淑鰲) in September/October 1707 and his fourth daughter married the Han Bannerman Sun Cheng'en (孫承恩) in February/March 1710.
Vietnam
The Lý, Trần, Hồ dynasties ruled Dai Viet (Vietnam) in a succession of heqin alliances.
Lý, Trần, Hồ dynasties
The Lý dynasty married its princesses off to regional rivals to establish alliances with them. The Lý family married one of their princesses (Lý Chiêu Hoàng) to a member of the Trần (Chen 陈) clan, Trần Thái Tông. This then enabled the Trần to topple the Lý and establish their own Trần dynasty.
The Tran dynasty engaged in a similar practice, marrying Tran princesses to regional allies. Later, the Hồ family, which was also of Chinese origin, established the Hồ dynasty, taking power after having a Tran princess marry one of their members, Hồ Quý Ly. A Lý princess also married into the Ho family.
Nguyen lords
The Cambodian King Chey Chettha II married the Vietnamese Nguyễn lord Princess Nguyễn Thị Ngọc Vạn, a daughter of Lord Nguyễn Phúc Nguyên, in 1618. In return, the king granted the Vietnamese the right to establish settlements in Mô Xoài (now Bà Rịa), in the region of Prey Nokor—which they colloquially referred to as Sài Gòn, and which later became Ho Chi Minh City.
Joseon
After the Qing conquest of Joseon, Joseon Korea was forced to give several of their royal princesses as concubines to the Qing regent Prince Dorgon, an ethnic Manchu. In 1650, Dorgon married the Korean Princess Uisun (義順). She was a collateral branches of the Korean royal family, and daughter of Yi Gae-yun (李愷胤). Dorgon married two Korean princesses at Lianshan.
See also
Marriage in China
Marriage of state, a similar practice in pre-modern Europe
Marriage of convenience
Malacca Sultanate
Women in ancient and imperial China
References
Citations
Bibliography
.
History of the foreign relations of China
History of Imperial China
Arranged marriage
Marriage, unions and partnerships in China
|
The Chaloem Maha Nakhon Expressway (), also known as the First Stage Expressway System (), is an expressway in Thailand, located in Bangkok. It is the first expressway to be opened in the country and is 27.1 kilometres in length. The expressway has played an important role in alleviating ground-level road traffic in Bangkok. The expressway is a controlled-access toll road.
Rama IX Bridge, is part of the Tha Ruea–Dao Khanong expressway section.
History
Due to a significant increase in road traffic in the Bangkok Metropolitan Region, an expressway system was proposed in order to alleviate the heavy ground-level road traffic and in preparation for the predicted increase in car usage. The Expressway Authority of Thailand (EXAT) was tasked to construct Thailand's first expressway in 1978 to connect three main highways leading out of Bangkok to the outlying provinces. This was Vibhavadi Rangsit Road to the north, Debaratna Road to the east and Rama II Road (Thonburi - Pak Tho Road) to the south. A total of 8.51 billion baht was invested in the project, with mainly government funding and some funding from Japan International Cooperation Agency (JICA).
The first section between Din Daeng–Tha Ruea was completed and unofficially opened on 29 October 1981. It was officially opened on 4 January 1982. Its northern end terminated at Vibhavadi Rangsit Road in Din Daeng district and its southern end terminated at Tha Ruea (Port) Junction near Bangkok Port in Khlong Toei district. The second section between Tha Ruea–Bang Na was opened on 17 January 1983 and connected Tha Ruea Junction to Debaratna Road in Bang Na district. The third section between Tha Ruea–Dao Khanong was opened on 5 December 1987 and connected Tha Ruea Junction to Rama II Road in Chom Thong district.
Due to increased road traffic on the expressway, Rama IX Bridge was expanded in 2020 and is expected to be completed in 2023.
According to an official EXAT annual report, the expressway was used by 104,765,797 cars in the 2022 fiscal year, with an average of 302,791 cars per day.
Route
Kilometre 0 is counted at Din Daeng Interchange.
See also
Controlled-access highways in Thailand
Expressway Authority of Thailand
References
Expressway Authority of Thailand expressways
|
```python
import random
import unittest
from typing import List
import numpy as np
import pandas as pd
import pytest
import torch
import torch.nn as nn
from snorkel.analysis import Scorer
from snorkel.classification import (
DictDataLoader,
DictDataset,
MultitaskClassifier,
Operation,
Task,
Trainer,
)
N_TRAIN = 1000
N_VALID = 300
class ClassifierConvergenceTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
# Ensure deterministic runs
random.seed(123)
np.random.seed(123)
torch.manual_seed(123)
@pytest.mark.complex
def test_convergence(self):
"""Test multitask classifier convergence with two tasks."""
dataloaders = []
for offset, task_name in zip([0.0, 0.25], ["task1", "task2"]):
df = create_data(N_TRAIN, offset)
dataloader = create_dataloader(df, "train", task_name)
dataloaders.append(dataloader)
for offset, task_name in zip([0.0, 0.25], ["task1", "task2"]):
df = create_data(N_VALID, offset)
dataloader = create_dataloader(df, "valid", task_name)
dataloaders.append(dataloader)
task1 = create_task("task1", module_suffixes=["A", "A"])
task2 = create_task("task2", module_suffixes=["A", "B"])
model = MultitaskClassifier(tasks=[task1, task2])
# Train
trainer = Trainer(lr=0.0024, n_epochs=10, progress_bar=False)
trainer.fit(model, dataloaders)
scores = model.score(dataloaders)
# Confirm near perfect scores on both tasks
for idx, task_name in enumerate(["task1", "task2"]):
self.assertGreater(scores[f"{task_name}/TestData/valid/accuracy"], 0.95)
# Calculate/check train/val loss
train_dataset = dataloaders[idx].dataset
train_loss_output = model.calculate_loss(
train_dataset.X_dict, train_dataset.Y_dict
)
train_loss = train_loss_output[0][task_name].item()
self.assertLess(train_loss, 0.05)
val_dataset = dataloaders[2 + idx].dataset
val_loss_output = model.calculate_loss(
val_dataset.X_dict, val_dataset.Y_dict
)
val_loss = val_loss_output[0][task_name].item()
self.assertLess(val_loss, 0.05)
def create_data(n: int, offset=0) -> pd.DataFrame:
"""Create uniform X data from [-1, 1] on both axes.
Create labels with linear decision boundaries related to the two coordinates of X.
"""
X = (np.random.random((n, 2)) * 2 - 1).astype(np.float32)
Y = (X[:, 0] < X[:, 1] + offset).astype(int)
df = pd.DataFrame({"x1": X[:, 0], "x2": X[:, 1], "y": Y})
return df
def create_dataloader(df: pd.DataFrame, split: str, task_name: str) -> DictDataLoader:
dataset = DictDataset(
name="TestData",
split=split,
X_dict={
"coordinates": torch.stack(
(torch.tensor(df["x1"]), torch.tensor(df["x2"])), dim=1
)
},
Y_dict={task_name: torch.tensor(df["y"], dtype=torch.long)},
)
dataloader = DictDataLoader(
dataset=dataset, batch_size=4, shuffle=(dataset.split == "train")
)
return dataloader
def create_task(task_name: str, module_suffixes: List[str]) -> Task:
module1_name = f"linear1{module_suffixes[0]}"
module2_name = f"linear2{module_suffixes[1]}"
module_pool = nn.ModuleDict(
{
module1_name: nn.Sequential(nn.Linear(2, 20), nn.ReLU()),
module2_name: nn.Linear(20, 2),
}
)
op1 = Operation(module_name=module1_name, inputs=[("_input_", "coordinates")])
op2 = Operation(module_name=module2_name, inputs=[op1.name])
op_sequence = [op1, op2]
task = Task(
name=task_name,
module_pool=module_pool,
op_sequence=op_sequence,
scorer=Scorer(metrics=["accuracy"]),
)
return task
if __name__ == "__main__":
unittest.main()
```
|
```html
<div class="shortcut-wrap">
<ul class="shortcut-menus">
{% for color in site.colors %}
<li><a class="shortcut {{ color }}" href="#{{ color }}">
<span class="list-color list-color-{{ color }}"></span>{{ site['colors'][forloop.index0] }}
</a></li>
{% endfor %}
</ul>
</div>
```
|
```javascript
// Mock Browser API's which are not supported by JSDOM, e.g. ServiceWorker, LocalStorage
/**
* An example how to mock localStorage is given below
*/
/*
// Mocks localStorage
const localStorageMock = (function() {
let store = {};
return {
getItem: (key) => store[key] || null,
setItem: (key, value) => store[key] = value.toString(),
clear: () => store = {}
};
})();
Object.defineProperty(window, 'localStorage', {
value: localStorageMock
}); */
```
|
```shell
#
# Kotlin
#
# A modern, concise and safe programming language
# Link: path_to_url
# your_sha256_hash--------------
# Configuration
# your_sha256_hash--------------
SPACESHIP_KOTLIN_SHOW="${SPACESHIP_KOTLIN_SHOW=true}"
SPACESHIP_KOTLIN_ASYNC="${SPACESHIP_KOTLIN_ASYNC=true}"
SPACESHIP_KOTLIN_PREFIX="${SPACESHIP_KOTLIN_PREFIX="$SPACESHIP_PROMPT_DEFAULT_PREFIX"}"
SPACESHIP_KOTLIN_SUFFIX="${SPACESHIP_KOTLIN_SUFFIX="$SPACESHIP_PROMPT_DEFAULT_SUFFIX"}"
SPACESHIP_KOTLIN_SYMBOL="${SPACESHIP_KOTLIN_SYMBOL=" "}"
SPACESHIP_KOTLIN_COLOR="${SPACESHIP_KOTLIN_COLOR="magenta"}"
# your_sha256_hash--------------
# Section
# your_sha256_hash--------------
spaceship_kotlin() {
[[ $SPACESHIP_KOTLIN_SHOW == false ]] && return
spaceship::exists kotlinc || return
[[ -n *.kt(#qN^/) || *.kts(#qN^/) ]] || return
# Extract kotlin version
local kotlin_version=$(kotlinc -version 2>&1 | spaceship::grep -oE '([0-9]+\.)([0-9]+\.)?([0-9]+)' | head -n 1)
[[ -z "$kotlin_version" ]] && return
spaceship::section \
--color "$SPACESHIP_KOTLIN_COLOR" \
--prefix "$SPACESHIP_KOTLIN_PREFIX" \
--suffix "$SPACESHIP_KOTLIN_SUFFIX" \
--symbol "$SPACESHIP_KOTLIN_SYMBOL" \
"v$kotlin_version"
}
```
|
Allison is an unincorporated community in Bryan County, Oklahoma, United States. It is located seven miles south of Durant, and had a post office from March 6, 1901, to December 15, 1921. Allison was named after the nearby Mount Allison school.
References
Unincorporated communities in Bryan County, Oklahoma
Unincorporated communities in Oklahoma
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.