text
stringlengths 1
22.8M
|
|---|
Antipodocottus elegans or the dwarf sculpin is a species of marine ray-finned fish belonging to the family Cottidae, the typical sculpins. Most commonly found in the benthic zone around depths of 400 meters, A. elegans is found almost exclusively near Wollongong in New South Wales, Australia.
References
Dwarf Sculpin, Antipodocottus elegans Fricke & Brunken 1984 & fishesofaustralia.net.au
External links
elegans
Fauna of New South Wales
Fish described in 1984
Taxa named by Ronald Fricke
|
Dactylopius opuntiae, also known as the prickly pear cochineal, is a species of scale insect in the family Dactylopiidae.
Taxonomy
Dactylopius opuntiae was first identified by Cockerell as Coccus cacti opuntiae after he collected it from cactus plants in Mexico in 1896. Later, it was considered a synonym of Dactylopius tomentosus, and workers often referred to the same species by different names or used the same name for different species. De Lotto notes that it became common practice to call Dactylopius opuntiae a distinct wild cochineal insect from Dactylopius tomentosus, even though their identity and status were never fully resolved. Eventually, in 1929, the species was classified as Dactylopius opuntiae by Cockerell.
Description
All species of the family Dactylopiidae have females with an oval-shaped body that is purple-red in color and covered in a white, cotton-like wax. This wax protects the body of the cochineal from heat, cold, and predators. Adult females are sessile and form colonies of up to a few thousand individuals of mixed age, creating conspicuous clusters of white wax all over the plant. Adult females of Dactylopius opuntiae produce red glucosidal hydroxyanthrapurin (carminic acid), which occurs naturally within their body. Morphologically, all Dactylopius species have truncate dorsal setae and clusters of quinquelocular pores associated with tubular ducts on the body of females, and no microducts and cellular anal rings bearing setae. Large, truncate, and rounded setae longer than the width at the base and numerous narrow ventral pores on the last three body segments distinguish Dactylopius opuntiae from all its congeners.
Development
Dactylopius opuntiae follows a life cycle similar to that of other species in the genus, consisting of two nymphal instars before adult females and two nymphal instars, prepupa, and pupa before adult males. Its biology has been studied in various regions, both in the laboratory and the open field, with female and male cycles lasting 77 and 43 days, respectively, in lab observations, and an offspring sex ratio of 3.7:1 (females:males) in greenhouse conditions. Field studies have shown that the female life cycle lasts 40–180 days, while males usually complete their cycle in 35–52 days. The optimal temperature for development is 30 °C, but males cannot emerge from the cocoon or adult females lay eggs at 35 °C, while crawlers' survival is negatively affected. The species usually reproduces bisexually, but it can reproduce by parthenogenesis under particular circumstances, such as high temperatures, resulting in lower progeny production.
The ovoviviparous females lay eggs one at a time beneath their bodies, with hatching occurring within 0.25–6 hours. Male and female crawlers are similar in appearance, but males of the Dactylopius austrinus species have shorter and fewer filaments than females. After a period of active dispersal, the crawlers settle down on the cladodes, often near the mother, and colonies are established at the joints of the cladode-trunk, flower-cladode, or fruit-cladode. Various factors can hinder cochineal development, including temperature, rain, and resistance factors of host plants. High temperatures and mechanical action of rain can negatively affect younger instars' survival, resulting in high mortality. Studies have shown that the species produces 4-5 generations per year in the Americas and Australia, with five generations occurring in the warmest areas.
Distribution
Dactylopius opuntiae is native to Mexico and neighboring countries in Central America but has been introduced to several other areas, including Australia, Algeria, Morocco, Israel, France, India, Kenya, Madagascar, Pakistan, South Africa, Sri Lanka, and the United States (California and Texas).
Host cacti
Opuntia ficus-indica
Opuntia fuliginosa
Opuntia humifusa
Opuntia hyptiacantha
Opuntia leucotricha
Opuntia littoralis
Opuntia engelmannii
Opuntia maxima
Opuntia ×occidentalis
Opuntia robusta
Opuntia streptacantha
Opuntia stricta
Opuntia tomentosa
Opuntia tuna
Tacinga palmadora
Ecology
Like other members of Dactylopiidae, Dactylopius opuntiae is not affected by parasitoid wasps. In Mexico, its most commonly occurring predatory species have been found to be Leucopis bellula, Sympherobius barberi, and Laetilia coccidivora.
Relationship with humans
Use as a biological control agent
In South Africa, Dactylopius opuntiae was introduced in 1932 along with three other insect species to control the cactus. Dactylopius opuntiae cleaned 75% of the infested areas, including those with the highest levels of opuntia infestation. Subsequently, about 90% of the original 900,000 ha returned to sheep-rearing due to the success of the cochineal as a biological control agent. However, dense populations of prickly pear still exist in cold and rainy areas, which are less favorable to the development of Dactylopius opuntiae. Subsequent introductions of Dactylopius opuntiae inside the Kruger National Park in the mid-1990s failed to control Opuntia stricta, confirming the importance of matching particular biotypes of biocontrol agents and host plants for weed control. A new strain of the cochineal was introduced from Opuntia stricta collected in Australia in 1997 with encouraging results. The genotype of Dactylopius opuntiae which effectively controlled Opuntia stricta in South Africa was also introduced in Kenya, resulting in the reduction in flowering and fruiting, and leading to the death of the plants.
De Souza & Hoffmann (2015) assessed the performance of Dactylopius opuntiae in controlling Opuntia monacantha, showing that it was less efficient than the congeneric Dactylopius ceylonicus, which provides complete biological control of this cactus species. Rule & Hoffmann (2018) investigated the effectiveness of the "stricta" biotype of Dactylopius opuntiae as a biological control agent for both Opuntia humifusa and Opuntia stricta. After a semi-field experiment, Dactylopius opuntiae was able to develop equally on both host plants. The dispersal capability of Dactylopius opuntiae away from the first areas of inoculum was assessed to promote a quicker spread of the scale insect. The colonies needed to be inoculated at no more than 10 m in between, as the spread of cochineal is primarily anemophilous. The efficacy of Dactylopius opuntiae is often limited by predator coccinellids and to a greater extent by rain. In South Africa, the use of prickly pear for human consumption, for forage, and as a host plant for the rearing of Dactylopius coccus has increased due to the reduction in the role of the prickly pear as a weed and the success of Dactylopius opuntiae as a biological control agent.
Dactylopius opuntiae can also have a strong negative impact on both the production of prickly pear fruit for fresh consumption and on cladodes as fodder for livestock feed. The cochineal species tends to form variably sized colonies on cladodes, which in some cases are totally covered by the insect. As a consequence, the fruits drop and cladodes dry out and fall off.
Pest
Dactylopius opuntiae can have a devastating impact on the production of both prickly pear fruit and cladodes as livestock feed. The species has a tendency to form colonies of varying sizes on cladodes, often completely covering the plant. This leads to the dropping of fruit and the drying out and eventual falling off of the cladodes. The damage starts with yellowish areas and necrosis on the cladodes, which then leads to drying out of the entire plant within a year. The woody stems can survive for another six months after this, but the damage is already done. The high population level of Dactylopius opuntiae weakens the plants, which pathogens attack, in turn causing their death.
In northeastern Brazil, Dactylopius opuntiae was imported from Mexico to produce dye, but it has caused significant damage to forage cactus production. In other Brazilian states such as Pernambuco, Paraíba, and Ceará, Dactylopius opuntiae infested over 100,000 hectares, resulting in more than US$100 million in annual damage, with serious socioeconomic consequences for farming communities where milk production is linked to prickly pear cultivation. Since its first detection in Morocco in September 2014, Dactylopius opuntiae has spread rapidly and caused serious damage to Opuntia ficus-indica plants, leading local authorities to uproot and incinerate over 400 hectares of plantations in the Doukkala region. The Moroccan Ministry of Agriculture implemented an emergency plan for Dactylopius opuntiae management in 2016, including a research program focusing on the most important components of cochineal management. Several insecticides such as chlorpyrifos, pyriproxyfen, acetamiprid, spirotetramat, and mineral oils have been authorized for use in Morocco to control the pest. However, chemical treatment of the cochineal colonies only provided temporary solutions against the pest. Several studies have observed that essential oils, botanical extracts, vegetable oils, detergents, and other bioactive chemicals have a strong insecticidal effect on the pest in cactus plantations. Bouharroud et al. (2018) evaluated the efficacy of D-Limonene, a widespread terpene, against Dactylopius opuntiae. The greatest female mortality rate was 99% at 150 ppm 6 days after treatment. Plant clones that are resistant to Dactylopius opuntiae can be an effective way to manage the pest. The thickness of the cactus plant's cuticle and epidermis, as well as the presence of calcium oxalate, play a crucial role in resistance to the pest. In Morocco, eight cultivars have shown immunity-type resistance to Dactylopius opuntiae, and more research is needed to develop resistant cultivars. Mechanical and physical methods, such as pruning and uprooting, can also be used to control the pest, but they are only effective when just a few plants are infested.
The extensive damage caused by Dactylopius opuntiae requires an integrated pest management (IPM) approach.
In 2012, Dactylopius opuntiae was first discovered in southern Lebanon on Opuntia ficus-indica plants. By 2014, the species was found to be widespread in the south of the country and causing severe damage to the cactus plants, whose fruit is an important source of income for local farmers. In 2015, new infestations were observed in neighboring regions. Although the predator beetle Cryptolaemus montrouzieri was found in association with the Dactylopius opuntiae colonies, their numbers were not high enough to control the pest population.
In 2013, the presence of Dactylopius opuntiae was reported for the first time in Israel. The insect was collected from Opuntia ficus-indica plants in the Hula Valley of the Upper Galilee.
The insect's natural predators help contain the damage they cause in Central American countries where Opuntia ficus-indica originates.
References
Insects of Mexico
Insects of Central America
Dactylopiidae
Insects described in 1929
|
```go
//
//
// 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.
//go:build python || all
package workspace
import (
"testing"
)
func TestPythonInstall(t *testing.T) {
t.Parallel()
testPluginInstall(t, "venv", map[string][]byte{
"PulumiPlugin.yaml": []byte("runtime: python\n"),
"package.json": []byte("pulumi==2.0.0\n"),
})
}
```
|
Jacques-Michel Hurel de Lamare (1 May 1772 – 27 March 1823) was a noted French cellist.
Lamare was born in Paris, to a poor family. He studied music at a very young age, entering the Institute of the Pages of the Royal Music at age 7, and turning to study of the cello, with Jean-Louis Duport, at age 15. He returned home upon the outbreak of the French Revolution in 1789.
In 1794, Lamare became cellist at the Théâtre Feydeau in Paris, where he developed a reputation as a soloist. He soon thereafter became a professor at the newly founded Conservatoire de Paris, while continuing to perform with the Feydeau. On the strength of his reputation as a performer he decided to leave both positions, and embarked on a tour giving performances abroad. From 1801 through 1809 he toured Germany and Russia, living mainly in Berlin, St. Petersburg, and Moscow. In Berlin, he became acquainted in particular with Prince Louis Ferdinand of Prussia.
Lamare returned to France in 1809, traveling through Poland and Austria. His return concert at the Odéon in April 1809, however, was not very well received, and thereafter he restricted himself to playing for private audiences, where he enjoyed greater acclaim. He married into wealth in 1815, after which he mostly retired from performance, dying in Caen in 1823.
His performance skills were legendary in their time, praised by François-Joseph Fétis among others. He does not appear to have been gifted as a composer, however, and it is not clear whether any works of his survive. Several works were published under his name during his lifetime, including four cello concertos, but these were likely composed by his close friend Daniel Auber.
References
1772 births
1823 deaths
Musicians from Paris
French classical cellists
|
Louis Joseph Lahure (29 November 1767 – 24 October 1853) was a general in the service of the First French Republic and First French Empire.
Biography
Early life
Louis Joseph Lahure was born on 29 November 1767 in Mons in the Austrian Netherlands. He was the son of Nicolas Lahure and Marie-Thérèse du Buisson. He had a brother, Germain Lahure. He studied at the Old University of Leuven.
Career
Lahure served in the Brabant Revolution in 1787. He moved to Lille in France in 1790. He served in the Army of the North under General Nicolas Luckner. He served in the Army of Sambre-et-Meuse.
He became a general. Occupying Holland in January 1795, the French continental army learned that the Dutch navy had been frozen into the ice near Texel Island. Lahure and 128 men simply rode up to it and demanded surrender. No shots were fired and the Dutch fleet was captured.
Lahure became a naturalised French citizen. He was made a Grand Officier of the Legion of Honour and the Order of Leopold. He was also made a Knight of the Order of Saint Louis.
Personal life
Lahure married Anne de Warenghien de Flory in 1800. They had seven children and resided at the de Wavrechain-sous-Faulx in northern France.
He died on 24 October 1853.
Legacy
His name is inscribed on the Arc de Triomphe in Paris. In 1895, Lahure's grandson published his memoirs.
References
1767 births
1853 deaths
Belgian generals
French military personnel of the French Revolutionary Wars
French military personnel of the Napoleonic Wars
Grand Officers of the Legion of Honour
People from Mons
People of the Brabant Revolution
Names inscribed under the Arc de Triomphe
Belgian emigrants to France
|
Leonid Kharitonovich Tibilov (; ; ; born 28 March 1951) is a South Ossetian politician who served as the President of South Ossetia from 2012 to 2017 after winning the 2012 South Ossetian presidential election.
Career
Leonid Tibilov headed the South Ossetian KGB as South Ossetia's Security Minister from 1992 to 1998. He was then a first deputy prime minister and co-chaired a Georgian-Ossetian peacekeeping commission. Tibilov stood at the 2006 presidential election losing to Eduard Kokoity, who won 98% of the vote.
Before the 2012 election Tibilov distanced himself from the outgoing President Kokoity. Tibilov is reported to be subservient to Russia and pledged to consult Russia before appointing a government if he was successful at the election.
In the first round of the 2012 Presidential election, Tibilov received 42.5% of the vote to lead David Sanakoyev. In the second round, Tibilov was elected president with 54.1% of the vote.
In a move towards integration with the Russian Federation, Tibilov proposed in December 2015 a name change to "South Ossetia–Alania" in analogy with "North Ossetia–Alania", a Russian federal subject. Tibilov furthermore suggested holding a referendum on joining the Russian Federation prior to April 2017, which would lead to a united "Ossetia–Alania". In April 2016, Tibilov said he intended to hold the referendum before August of that year. However, on 30 May, Tibilov postponed the referendum until after the presidential election due in April 2017. At the 2017 South Ossetian name change referendum, nearly 80 percent of those who voted endorsed the name-change, while the presidential race was won by Anatoly Bibilov – against the incumbent, Tibilov, who had been supported by Moscow and who, unlike Bibilov, was ready to heed Moscow's wish for the integration referendum not be held any time soon. However, Bibilov posteriorly also stated that a referendum would probably be done in 2017, although he still said that it could be postponed.
References
1951 births
Living people
Ossetian people
People from Znaur district
Presidents of South Ossetia
South Ossetian politicians
|
```c
/*
* Westwood Studios AUD Format Demuxer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*
* FFmpeg 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 GNU
*
* You should have received a copy of the GNU Lesser General Public
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* Westwood Studios AUD file demuxer
* by Mike Melanson (melanson@pcisys.net)
* for more information on the Westwood file formats, visit:
* path_to_url~melanson/codecs/
* path_to_url
*
* Implementation note: There is no definite file signature for AUD files.
* The demuxer uses a probabilistic strategy for content detection. This
* entails performing sanity checks on certain header values in order to
* qualify a file. Refer to wsaud_probe() for the precise parameters.
*/
#include "libavutil/channel_layout.h"
#include "libavutil/intreadwrite.h"
#include "avformat.h"
#include "internal.h"
#define AUD_HEADER_SIZE 12
#define AUD_CHUNK_PREAMBLE_SIZE 8
#define AUD_CHUNK_SIGNATURE 0x0000DEAF
static int wsaud_probe(AVProbeData *p)
{
int field;
/* Probabilistic content detection strategy: There is no file signature
* so perform sanity checks on various header parameters:
* 8000 <= sample rate (16 bits) <= 48000 ==> 40001 acceptable numbers
* flags <= 0x03 (2 LSBs are used) ==> 4 acceptable numbers
* compression type (8 bits) = 1 or 99 ==> 2 acceptable numbers
* first audio chunk signature (32 bits) ==> 1 acceptable number
* The number space contains 2^64 numbers. There are 40001 * 4 * 2 * 1 =
* 320008 acceptable number combinations.
*/
if (p->buf_size < AUD_HEADER_SIZE + AUD_CHUNK_PREAMBLE_SIZE)
return 0;
/* check sample rate */
field = AV_RL16(&p->buf[0]);
if ((field < 8000) || (field > 48000))
return 0;
/* enforce the rule that the top 6 bits of this flags field are reserved (0);
* this might not be true, but enforce it until deemed unnecessary */
if (p->buf[10] & 0xFC)
return 0;
if (p->buf[11] != 99 && p->buf[11] != 1)
return 0;
/* read ahead to the first audio chunk and validate the first header signature */
if (AV_RL32(&p->buf[16]) != AUD_CHUNK_SIGNATURE)
return 0;
/* return 1/2 certainty since this file check is a little sketchy */
return AVPROBE_SCORE_EXTENSION;
}
static int wsaud_read_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
AVStream *st;
unsigned char header[AUD_HEADER_SIZE];
int sample_rate, channels, codec;
if (avio_read(pb, header, AUD_HEADER_SIZE) != AUD_HEADER_SIZE)
return AVERROR(EIO);
sample_rate = AV_RL16(&header[0]);
channels = (header[10] & 0x1) + 1;
codec = header[11];
/* initialize the audio decoder stream */
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
switch (codec) {
case 1:
if (channels != 1) {
avpriv_request_sample(s, "Stereo WS-SND1");
return AVERROR_PATCHWELCOME;
}
st->codecpar->codec_id = AV_CODEC_ID_WESTWOOD_SND1;
break;
case 99:
st->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_WS;
st->codecpar->bits_per_coded_sample = 4;
st->codecpar->bit_rate = channels * sample_rate * 4;
break;
default:
avpriv_request_sample(s, "Unknown codec: %d", codec);
return AVERROR_PATCHWELCOME;
}
avpriv_set_pts_info(st, 64, 1, sample_rate);
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codecpar->channels = channels;
st->codecpar->channel_layout = channels == 1 ? AV_CH_LAYOUT_MONO :
AV_CH_LAYOUT_STEREO;
st->codecpar->sample_rate = sample_rate;
return 0;
}
static int wsaud_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
AVIOContext *pb = s->pb;
unsigned char preamble[AUD_CHUNK_PREAMBLE_SIZE];
unsigned int chunk_size;
int ret = 0;
AVStream *st = s->streams[0];
if (avio_read(pb, preamble, AUD_CHUNK_PREAMBLE_SIZE) !=
AUD_CHUNK_PREAMBLE_SIZE)
return AVERROR(EIO);
/* validate the chunk */
if (AV_RL32(&preamble[4]) != AUD_CHUNK_SIGNATURE)
return AVERROR_INVALIDDATA;
chunk_size = AV_RL16(&preamble[0]);
if (st->codecpar->codec_id == AV_CODEC_ID_WESTWOOD_SND1) {
/* For Westwood SND1 audio we need to add the output size and input
size to the start of the packet to match what is in VQA.
Specifically, this is needed to signal when a packet should be
decoding as raw 8-bit pcm or variable-size ADPCM. */
int out_size = AV_RL16(&preamble[2]);
if ((ret = av_new_packet(pkt, chunk_size + 4)) < 0)
return ret;
if ((ret = avio_read(pb, &pkt->data[4], chunk_size)) != chunk_size)
return ret < 0 ? ret : AVERROR(EIO);
AV_WL16(&pkt->data[0], out_size);
AV_WL16(&pkt->data[2], chunk_size);
pkt->duration = out_size;
} else {
ret = av_get_packet(pb, pkt, chunk_size);
if (ret != chunk_size)
return AVERROR(EIO);
if (st->codecpar->channels <= 0) {
av_log(s, AV_LOG_ERROR, "invalid number of channels %d\n",
st->codecpar->channels);
return AVERROR_INVALIDDATA;
}
/* 2 samples/byte, 1 or 2 samples per frame depending on stereo */
pkt->duration = (chunk_size * 2) / st->codecpar->channels;
}
pkt->stream_index = st->index;
return ret;
}
AVInputFormat ff_wsaud_demuxer = {
.name = "wsaud",
.long_name = NULL_IF_CONFIG_SMALL("Westwood Studios audio"),
.read_probe = wsaud_probe,
.read_header = wsaud_read_header,
.read_packet = wsaud_read_packet,
};
```
|
```c++
{
// Replace one toolbar bitmap with another.
TBREPLACEBITMAP tbrb;
tbrb.hInstOld = ::AfxGetInstanceHandle();
tbrb.nIDOld = IDR_MAINFRAME;
tbrb.hInstNew = ::AfxGetInstanceHandle();
tbrb.nIDNew = IDR_MAINFRAME1;
tbrb.nButtons = 8;
CToolBarCtrl &m_toolBarCtrl = m_wndToolBar.GetToolBarCtrl();
BOOL bRet = m_toolBarCtrl.ReplaceBitmap(&tbrb);
}
```
|
Thomas Ludwig Herbst (27 July 1848, in Hamburg – 19 January 1915, in Hamburg) was a German Impressionist painter; known mostly for landscapes and animal portraits.
Biography
He took his first lessons in 1865 with Jakob Becker at the Städelsches Kunstinstitut in Frankfurt. The following year, he transferred to the Prussian Academy of Arts in Berlin, where he worked with Carl Steffeck. In 1868, he transferred again, this time to the Weimar Saxon Grand Ducal Art School, where he took advanced studies with Charles Verlat.
From 1873 to 1876, he lived in Düsseldorf and took several trips to the Netherlands. He then spent a year in Paris with his friend, Max Liebermann, before moving to Munich, where he came into contact with the Munich Secession and Wilhelm Leibl.
In 1884, he returned to Hamburg and became a drawing teacher at the "Vocational School for Women". More training followed in 1890, with the landscape painter, Carl Rodeck. In 1897, he became one of the founding members of the but, according to Arthur Siebelist, resigned in 1903 because he did not like their "cultural standards".
In 1906, he went on an extended study trip to Holstein with Friedrich Ahlers-Hestermann. In later years, he acquired the nickname "Kuhherbst" (Kuh means Cow), in reference to one of his favorite subjects.
In 2015, on the centennial of his death, the Jenisch House in Hamburg held a major retrospective of his works.
References
Further reading
Carsten Meyer-Tönnesmann: Der Hamburgische Künstlerclub von 1897. Atelier im Bauernhaus, Fischerhude 1997, .
Hans-Jörg Czech, Carsten Meyer-Tönnesmann, Nicole Tiedemann-Bischop (Eds.): Thomas Herbst. 1848–1915. Liebermanns Freund, Lichtwarks Hoffnung. (exhibition catalog, Hamburg Historical Museum Foundation), Atelier im Bauernhaus, 2015
External links
ArtNet: More works by Herbst.
1848 births
1915 deaths
Artists from Hamburg
19th-century German painters
19th-century German male artists
German male painters
20th-century German painters
20th-century German male artists
German Impressionist painters
Prussian Academy of Arts alumni
|
is a Japanese film director best known for directing The Taste of Tea (2004), Funky Forest (2005), and Smuggler (2011).
Career
After graduating from Musashino Art University, Ishii got a job at Tohokushinsha Film and began directing commercials in 1992, receiving numerous awards in this field. His first short film, The Promise of August, shot in 1995, received the Japanese Film Grand Prix in the Fantastic Video Section of the 1995 Yubari International Fantastic Film Festival
He made his feature debut with Shark Skin Man and Peach Hip Girl, based on the visual novel by cult manga artist Minetaro Mochizuki and starring regular collaborator Tadanobu Asano.
Ishii quickly followed his success with another box office hit, Party 7 (2000), which featured Masatoshi Nagase, Yoshio Harada and Tadanobu Asano among others. Between the years 2001 and 2002, he created a series of short films including the 3D animated dialogue piece Hal & Bons and the 2D animated space opera Trava Fist Planet. Among other commercials and select TV projects including the short Black Room which starred Takuya Kimura, and Music Power Go Go!, He collaborated with Production I.G for the animation sequence of Quentin Tarantino's Kill Bill: Volume 1.
In 2004, his fourth feature film The Taste of Tea won Best Feature Film at the Hawaii International Film Festival. In 2006, he co-directed the feature film Funky Forest with fellow Japanese film makers and old school friends Shunichiro Miki and ANIKI. He founded his own production company, Nice Rainbow, in October 2006.
Selected filmography
Shark Skin Man and Peach Hip Girl (1999) starring Tadanobu Asano
Party 7 (2000) starring Tadanobu Asano
Trava Fist Planet episode 1 (2001–2002, short series, animation)
The Taste of Tea (2004) starring Tadanobu Asano, Maya Banno, Takahiro Sato, Tomokazu Miura, Anna Tsuchiya
Funky Forest (2005) starring Tadanobu Asano, Susumu Terajima, Ryō Kase, Rinko Kikuchi
Yama no Anata (2008, remake of 1938 film The Masseurs and a Woman)
Redline (2009)
Smuggler (2011)
References
External links
Japanese film directors
Living people
1966 births
People from Niigata Prefecture
|
```yaml
prelude:
|
Released on: 2020-12-10
Pinned to datadog-agent v7.24.0: `CHANGELOG <path_to_url#7240--6240>`_.
```
|
```html
<html>
<head>
<title>NVIDIA(R) PhysX(R) SDK 3.4 API Reference: PxPhysXCommonConfig.h Source File</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<LINK HREF="NVIDIA.css" REL="stylesheet" TYPE="text/css">
</head>
<body bgcolor="#FFFFFF">
<div id="header">
<hr class="first">
<img alt="" src="images/PhysXlogo.png" align="middle"> <br>
<center>
<a class="qindex" href="main.html">Main Page</a>
<a class="qindex" href="hierarchy.html">Class Hierarchy</a>
<a class="qindex" href="annotated.html">Compound List</a>
<a class="qindex" href="functions.html">Compound Members</a>
</center>
<hr class="second">
</div>
<!-- Generated by Doxygen 1.5.8 -->
<h1>PxPhysXCommonConfig.h</h1><a href="PxPhysXCommonConfig_8h.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 <span class="comment">//</span>
<a name="l00002"></a>00002 <span class="comment">// Redistribution and use in source and binary forms, with or without</span>
<a name="l00003"></a>00003 <span class="comment">// modification, are permitted provided that the following conditions</span>
<a name="l00004"></a>00004 <span class="comment">// are met:</span>
<a name="l00005"></a>00005 <span class="comment">// * Redistributions of source code must retain the above copyright</span>
<a name="l00006"></a>00006 <span class="comment">// notice, this list of conditions and the following disclaimer.</span>
<a name="l00007"></a>00007 <span class="comment">// * Redistributions in binary form must reproduce the above copyright</span>
<a name="l00008"></a>00008 <span class="comment">// notice, this list of conditions and the following disclaimer in the</span>
<a name="l00009"></a>00009 <span class="comment">// documentation and/or other materials provided with the distribution.</span>
<a name="l00010"></a>00010 <span class="comment">// * Neither the name of NVIDIA CORPORATION nor the names of its</span>
<a name="l00011"></a>00011 <span class="comment">// contributors may be used to endorse or promote products derived</span>
<a name="l00012"></a>00012 <span class="comment">// from this software without specific prior written permission.</span>
<a name="l00013"></a>00013 <span class="comment">//</span>
<a name="l00014"></a>00014 <span class="comment">// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY</span>
<a name="l00015"></a>00015 <span class="comment">// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE</span>
<a name="l00016"></a>00016 <span class="comment">// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR</span>
<a name="l00017"></a>00017 <span class="comment">// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR</span>
<a name="l00018"></a>00018 <span class="comment">// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,</span>
<a name="l00019"></a>00019 <span class="comment">// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,</span>
<a name="l00020"></a>00020 <span class="comment">// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR</span>
<a name="l00021"></a>00021 <span class="comment">// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY</span>
<a name="l00022"></a>00022 <span class="comment">// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT</span>
<a name="l00023"></a>00023 <span class="comment">// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE</span>
<a name="l00024"></a>00024 <span class="comment">// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</span>
<a name="l00025"></a>00025 <span class="comment">//</span>
<a name="l00029"></a>00029
<a name="l00030"></a>00030
<a name="l00031"></a>00031 <span class="preprocessor">#ifndef PX_PHYSICS_COMMON_NX</span>
<a name="l00032"></a>00032 <span class="preprocessor"></span><span class="preprocessor">#define PX_PHYSICS_COMMON_NX</span>
<a name="l00033"></a>00033 <span class="preprocessor"></span>
<a name="l00037"></a>00037 <span class="preprocessor">#include "<a class="code" href="Px_8h.html">foundation/Px.h</a>"</span>
<a name="l00038"></a>00038
<a name="l00039"></a>00039 <span class="comment">/*Disable support for VS2017 prior version 15.5.1 for windows platform, because of a compiler bug:</span>
<a name="l00040"></a>00040 <span class="comment">path_to_url
<a name="l00041"></a>00041 <span class="comment">*/</span>
<a name="l00042"></a>00042 <span class="preprocessor">#if (PX_VC == 15) && PX_WINDOWS && (_MSC_FULL_VER < 191225830)</span>
<a name="l00043"></a>00043 <span class="preprocessor"></span><span class="preprocessor">#error Visual studio 2017 prior to 15.5.1 is not supported because of a compiler bug.</span>
<a name="l00044"></a>00044 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00045"></a>00045 <span class="preprocessor"></span>
<a name="l00046"></a>00046 <span class="comment">// define API function declaration (public API only needed because of extensions)</span>
<a name="l00047"></a>00047 <span class="preprocessor">#if defined PX_PHYSX_STATIC_LIB || defined PX_PHYSX_CORE_STATIC_LIB</span>
<a name="l00048"></a>00048 <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_CORE_API</span>
<a name="l00049"></a>00049 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00050"></a>00050 <span class="preprocessor"></span><span class="preprocessor"> #if PX_WINDOWS</span>
<a name="l00051"></a>00051 <span class="preprocessor"></span><span class="preprocessor"> #if defined PX_PHYSX_CORE_EXPORTS</span>
<a name="l00052"></a>00052 <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_CORE_API __declspec(dllexport)</span>
<a name="l00053"></a>00053 <span class="preprocessor"></span><span class="preprocessor"> #else</span>
<a name="l00054"></a>00054 <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_CORE_API __declspec(dllimport)</span>
<a name="l00055"></a>00055 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00056"></a>00056 <span class="preprocessor"></span><span class="preprocessor"> #elif PX_UNIX_FAMILY</span>
<a name="l00057"></a>00057 <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_CORE_API PX_UNIX_EXPORT</span>
<a name="l00058"></a>00058 <span class="preprocessor"></span><span class="preprocessor"> #else</span>
<a name="l00059"></a><a class="code" href="group__common.html#g4636d12a5a01930fa258136f3f93366f">00059</a> <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_CORE_API</span>
<a name="l00060"></a>00060 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00061"></a>00061 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00062"></a>00062 <span class="preprocessor"></span>
<a name="l00063"></a>00063 <span class="preprocessor">#if PX_SUPPORT_GPU_PHYSX</span>
<a name="l00064"></a>00064 <span class="preprocessor"></span>
<a name="l00065"></a>00065 <span class="comment">// define API function declaration</span>
<a name="l00066"></a>00066 <span class="preprocessor">#if PX_WINDOWS </span>
<a name="l00067"></a>00067 <span class="preprocessor"></span><span class="preprocessor">#if defined PX_PHYSX_GPU_EXPORTS</span>
<a name="l00068"></a>00068 <span class="preprocessor"></span><span class="preprocessor">#define PX_PHYSX_GPU_API __declspec(dllexport)</span>
<a name="l00069"></a>00069 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00070"></a>00070 <span class="preprocessor"></span><span class="preprocessor">#define PX_PHYSX_GPU_API __declspec(dllimport)</span>
<a name="l00071"></a>00071 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00072"></a>00072 <span class="preprocessor"></span><span class="preprocessor">#elif PX_UNIX_FAMILY</span>
<a name="l00073"></a>00073 <span class="preprocessor"></span><span class="preprocessor">#define PX_PHYSX_GPU_API PX_UNIX_EXPORT</span>
<a name="l00074"></a>00074 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00075"></a>00075 <span class="preprocessor"></span><span class="preprocessor">#define PX_PHYSX_GPU_API</span>
<a name="l00076"></a>00076 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00077"></a>00077 <span class="preprocessor"></span>
<a name="l00078"></a>00078 <span class="preprocessor">#else // PX_SUPPORT_GPU_PHYSX</span>
<a name="l00079"></a><a class="code" href="group__common.html#gbe7c1438b281afb1d13fdc127cc84e68">00079</a> <span class="preprocessor"></span><span class="preprocessor">#define PX_PHYSX_GPU_API</span>
<a name="l00080"></a>00080 <span class="preprocessor"></span><span class="preprocessor">#endif // PX_SUPPORT_GPU_PHYSX</span>
<a name="l00081"></a>00081 <span class="preprocessor"></span>
<a name="l00082"></a>00082 <span class="preprocessor">#if PX_WINDOWS && !defined(__CUDACC__)</span>
<a name="l00083"></a>00083 <span class="preprocessor"></span><span class="preprocessor"> #if defined PX_PHYSX_COMMON_EXPORTS</span>
<a name="l00084"></a>00084 <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_COMMON_API __declspec(dllexport)</span>
<a name="l00085"></a>00085 <span class="preprocessor"></span><span class="preprocessor"> #else</span>
<a name="l00086"></a>00086 <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_COMMON_API __declspec(dllimport)</span>
<a name="l00087"></a>00087 <span class="preprocessor"></span><span class="preprocessor"> #endif</span>
<a name="l00088"></a>00088 <span class="preprocessor"></span><span class="preprocessor">#elif PX_UNIX_FAMILY</span>
<a name="l00089"></a>00089 <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_COMMON_API PX_UNIX_EXPORT</span>
<a name="l00090"></a>00090 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00091"></a><a class="code" href="group__common.html#g87ae1d60bdf83754e2fe5065aab40ec4">00091</a> <span class="preprocessor"></span><span class="preprocessor"> #define PX_PHYSX_COMMON_API</span>
<a name="l00092"></a>00092 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00093"></a>00093 <span class="preprocessor"></span>
<a name="l00094"></a>00094 <span class="comment">// Changing these parameters requires recompilation of the SDK</span>
<a name="l00095"></a>00095
<a name="l00096"></a>00096 <span class="preprocessor">#if !PX_DOXYGEN</span>
<a name="l00097"></a>00097 <span class="preprocessor"></span><span class="keyword">namespace </span>physx
<a name="l00098"></a>00098 {
<a name="l00099"></a>00099 <span class="preprocessor">#endif</span>
<a name="l00100"></a>00100 <span class="preprocessor"></span> <span class="keyword">class </span><a class="code" href="classPxCollection.html" title="Collection class for serialization.">PxCollection</a>;
<a name="l00101"></a>00101 <span class="keyword">class </span><a class="code" href="classPxBase.html" title="Base class for objects that can be members of a PxCollection.">PxBase</a>;
<a name="l00102"></a>00102
<a name="l00103"></a>00103 <span class="keyword">class </span><a class="code" href="classPxHeightField.html" title="A height field class.">PxHeightField</a>;
<a name="l00104"></a>00104 <span class="keyword">class </span><a class="code" href="classPxHeightFieldDesc.html" title="Descriptor class for PxHeightField.">PxHeightFieldDesc</a>;
<a name="l00105"></a>00105
<a name="l00106"></a>00106 <span class="keyword">class </span><a class="code" href="classPxTriangleMesh.html" title="A triangle mesh, also called a &#39;polygon soup&#39;.">PxTriangleMesh</a>;
<a name="l00107"></a><a class="code" href="group__common.html#g19403877bf7ce42d7240e4e4c758c016">00107</a> <span class="keyword">class </span><a class="code" href="classPxConvexMesh.html" title="A convex mesh.">PxConvexMesh</a>;
<a name="l00108"></a>00108
<a name="l00109"></a>00109 <span class="keyword">typedef</span> <a class="code" href="namespacephysx.html#9b7fbd746d18bf5b6545713a8d818f41">PxU32</a> <a class="code" href="group__common.html#g19403877bf7ce42d7240e4e4c758c016">PxTriangleID</a>;
<a name="l00110"></a><a class="code" href="group__common.html#gc816bc62a68a52f01bf21f963295e822">00110</a> <span class="keyword">typedef</span> <a class="code" href="namespacephysx.html#9caf1cbcda071b6d2a9c069faa99da23">PxU16</a> <a class="code" href="group__common.html#gc816bc62a68a52f01bf21f963295e822">PxMaterialTableIndex</a>;
<a name="l00111"></a>00111
<a name="l00112"></a>00112 <span class="preprocessor">#if !PX_DOXYGEN</span>
<a name="l00113"></a>00113 <span class="preprocessor"></span>} <span class="comment">// namespace physx</span>
<a name="l00114"></a>00114 <span class="preprocessor">#endif</span>
<a name="l00115"></a>00115 <span class="preprocessor"></span>
<a name="l00117"></a>00117 <span class="preprocessor">#endif</span>
</pre></div></div>
<hr style="width: 100%; height: 2px;"><br>
</body>
</html>
```
|
```javascript
//your_sha256_hash---------------------------------------
//your_sha256_hash---------------------------------------
function lifetime_memset(arr, n) {
if(arr[n - 1] !== 0) {
for(var i = 0; i < n; ++i) {
arr[i] = 0;
}
}
}
function lifetime_memcopy(arr, arr2, n) {
if(arr[n - 1] !== 1) {
for(var i = 0; i < n; ++i) {
arr[i] = arr2[i];
}
}
}
var n = 8;
var arr = Array(n);
var arr2 = Array(n);
lifetime_memset(arr, n);
lifetime_memset(arr2, n);
lifetime_memcopy(arr, arr2, n);
lifetime_memcopy(arr, arr2, n);
print("PASSED");
```
|
```xml
import { OperationOrFragment, SourceWithOperations } from '@graphql-codegen/gql-tag-operations';
import { Source } from '@graphql-tools/utils';
import { FragmentDefinitionNode, OperationDefinitionNode } from 'graphql';
export type BuildNameFunction = (type: OperationDefinitionNode | FragmentDefinitionNode) => string;
export function processSources(sources: Array<Source>, buildName: BuildNameFunction) {
const sourcesWithOperations: Array<SourceWithOperations> = [];
for (const originalSource of sources) {
const source = fixLinebreaks(originalSource);
const { document } = source;
const operations: Array<OperationOrFragment> = [];
for (const definition of document?.definitions ?? []) {
if (definition?.kind !== `OperationDefinition` && definition?.kind !== 'FragmentDefinition') continue;
if (definition.name?.kind !== `Name`) {
if (definition?.kind === `OperationDefinition`) {
// eslint-disable-next-line no-console
console.warn(`[client-preset] the following anonymous operation is skipped: ${source.rawSDL}`);
}
continue;
}
operations.push({
initialName: buildName(definition),
definition,
});
}
if (operations.length === 0) continue;
sourcesWithOperations.push({
source,
operations,
});
}
return sourcesWithOperations;
}
/**
* path_to_url
*
* Source file is read by @graphql/tools using fs.promises.readFile,
* which means that the linebreaks are read as-is and the result will be different
* depending on the OS: it will contain LF (\n) on Linux/MacOS and CRLF (\r\n) on Windows.
*
* In most scenarios that would be OK. However, front-end preset is using the resulting string
* as a TypeScript type. Which means that the string will be compared against a template literal,
* for example:
*
* <pre><code>
* `
* query a {
* a
* }
* ` === '\n query a {\n a\n }\n '
* </code></pre>
*
* According to clause 12.8.6.2 of ECMAScript Language Specification
* (path_to_url#sec-static-semantics-trv),
* when comparing strings, JavaScript doesn't care which linebreaks does the source file contain,
* any linebreak (CR, LF or CRLF) is LF from JavaScript standpoint
* (otherwise the result of the above comparison would be OS-dependent, which doesn't make sense).
*
* Therefore gql-tag-operation would break on Windows as it would generate
*
* '\r\n query a {\r\n a\r\n }\r\n '
*
* which is NOT equal to
*
* <pre><code>
* `
* query a {
* a
* }
* `
* </code></pre>
*
* Therefore we need to replace \r\n with \n in the string.
*
* @param source
*/
function fixLinebreaks(source: Source) {
const fixedSource = { ...source };
fixedSource.rawSDL = source.rawSDL.replace(/\r\n/g, '\n');
return fixedSource;
}
```
|
```python
# 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
"""
This file provides utilities for running AOT tests, especially for Corstone.
"""
import logging
import itertools
import shutil
import pytest
import tvm
from tvm.testing.aot import AOTTestRunner
pytest.importorskip("tvm.micro")
_LOG = logging.getLogger(__name__)
AOT_DEFAULT_RUNNER = AOTTestRunner()
# AOT Test Runner using the Arm Corstone-300 Reference Systems
# see: path_to_url
AOT_CORSTONE300_RUNNER = AOTTestRunner(
makefile="corstone300",
prologue="""
UartStdOutInit();
""",
includes=["uart_stdout.h"],
pass_config={
"relay.ext.cmsisnn.options": {
"mcpu": "cortex-m55",
}
},
)
AOT_USMP_CORSTONE300_RUNNER = AOTTestRunner(
makefile="corstone300",
prologue="""
UartStdOutInit();
""",
includes=["uart_stdout.h"],
pass_config={
"relay.ext.cmsisnn.options": {
"mcpu": "cortex-m55",
},
"tir.usmp.enable": True,
},
)
AOT_APROFILE_AEM_RUNNER = AOTTestRunner(
makefile="aprofile_aem",
includes=[],
pass_config={
"tir.usmp.enable": False,
# AOT test infra generates 'fake' tensor inputs which fails asserts
"tir.disable_assert": True,
},
)
def parametrize_aot_options(test):
"""Parametrize over valid option combinations"""
requires_arm_eabi = pytest.mark.skipif(
shutil.which("arm-none-eabi-gcc") is None, reason="ARM embedded toolchain unavailable"
)
interface_api = ["packed", "c"]
use_unpacked_api = [True, False]
test_runner = [AOT_DEFAULT_RUNNER, AOT_CORSTONE300_RUNNER]
all_combinations = itertools.product(interface_api, use_unpacked_api, test_runner)
# Filter out packed operators with c interface
valid_combinations = filter(
lambda parameters: not (parameters[0] == "c" and not parameters[1]),
all_combinations,
)
# Only use reference system for C interface and unpacked API calls
valid_combinations = filter(
lambda parameters: not (
parameters[2] == AOT_CORSTONE300_RUNNER
and (parameters[0] == "packed" or not parameters[1])
),
valid_combinations,
)
# Skip reference system tests if running in i386 container
marked_combinations = map(
lambda parameters: pytest.param(*parameters, marks=[requires_arm_eabi])
if parameters[2] == AOT_CORSTONE300_RUNNER
else parameters,
valid_combinations,
)
func = pytest.mark.parametrize(
["interface_api", "use_unpacked_api", "test_runner"],
marked_combinations,
)(test)
return tvm.testing.skip_if_32bit(reason="Reference system unavailable in i386 container")(func)
```
|
```yaml
models:
- columns:
- name: id
tests:
- unique
- not_null
- relationships:
field: id
to: ref('node_0')
name: node_1980
version: 2
```
|
```assembly
; This file is generated from a similarly-named Perl script in the BoringSSL
; source tree. Do not edit by hand.
%ifidn __OUTPUT_FORMAT__, win64
default rel
%define XMMWORD
%define YMMWORD
%define ZMMWORD
%define _CET_ENDBR
%ifdef BORINGSSL_PREFIX
%include "boringssl_prefix_symbols_nasm.inc"
%endif
section .text code align=64
global sha1_block_data_order_nohw
ALIGN 16
sha1_block_data_order_nohw:
mov QWORD[8+rsp],rdi ;WIN64 prologue
mov QWORD[16+rsp],rsi
mov rax,rsp
$L$SEH_begin_sha1_block_data_order_nohw:
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
_CET_ENDBR
mov rax,rsp
push rbx
push rbp
push r12
push r13
push r14
mov r8,rdi
sub rsp,72
mov r9,rsi
and rsp,-64
mov r10,rdx
mov QWORD[64+rsp],rax
$L$prologue:
mov esi,DWORD[r8]
mov edi,DWORD[4+r8]
mov r11d,DWORD[8+r8]
mov r12d,DWORD[12+r8]
mov r13d,DWORD[16+r8]
jmp NEAR $L$loop
ALIGN 16
$L$loop:
mov edx,DWORD[r9]
bswap edx
mov ebp,DWORD[4+r9]
mov eax,r12d
mov DWORD[rsp],edx
mov ecx,esi
bswap ebp
xor eax,r11d
rol ecx,5
and eax,edi
lea r13d,[1518500249+r13*1+rdx]
add r13d,ecx
xor eax,r12d
rol edi,30
add r13d,eax
mov r14d,DWORD[8+r9]
mov eax,r11d
mov DWORD[4+rsp],ebp
mov ecx,r13d
bswap r14d
xor eax,edi
rol ecx,5
and eax,esi
lea r12d,[1518500249+r12*1+rbp]
add r12d,ecx
xor eax,r11d
rol esi,30
add r12d,eax
mov edx,DWORD[12+r9]
mov eax,edi
mov DWORD[8+rsp],r14d
mov ecx,r12d
bswap edx
xor eax,esi
rol ecx,5
and eax,r13d
lea r11d,[1518500249+r11*1+r14]
add r11d,ecx
xor eax,edi
rol r13d,30
add r11d,eax
mov ebp,DWORD[16+r9]
mov eax,esi
mov DWORD[12+rsp],edx
mov ecx,r11d
bswap ebp
xor eax,r13d
rol ecx,5
and eax,r12d
lea edi,[1518500249+rdi*1+rdx]
add edi,ecx
xor eax,esi
rol r12d,30
add edi,eax
mov r14d,DWORD[20+r9]
mov eax,r13d
mov DWORD[16+rsp],ebp
mov ecx,edi
bswap r14d
xor eax,r12d
rol ecx,5
and eax,r11d
lea esi,[1518500249+rsi*1+rbp]
add esi,ecx
xor eax,r13d
rol r11d,30
add esi,eax
mov edx,DWORD[24+r9]
mov eax,r12d
mov DWORD[20+rsp],r14d
mov ecx,esi
bswap edx
xor eax,r11d
rol ecx,5
and eax,edi
lea r13d,[1518500249+r13*1+r14]
add r13d,ecx
xor eax,r12d
rol edi,30
add r13d,eax
mov ebp,DWORD[28+r9]
mov eax,r11d
mov DWORD[24+rsp],edx
mov ecx,r13d
bswap ebp
xor eax,edi
rol ecx,5
and eax,esi
lea r12d,[1518500249+r12*1+rdx]
add r12d,ecx
xor eax,r11d
rol esi,30
add r12d,eax
mov r14d,DWORD[32+r9]
mov eax,edi
mov DWORD[28+rsp],ebp
mov ecx,r12d
bswap r14d
xor eax,esi
rol ecx,5
and eax,r13d
lea r11d,[1518500249+r11*1+rbp]
add r11d,ecx
xor eax,edi
rol r13d,30
add r11d,eax
mov edx,DWORD[36+r9]
mov eax,esi
mov DWORD[32+rsp],r14d
mov ecx,r11d
bswap edx
xor eax,r13d
rol ecx,5
and eax,r12d
lea edi,[1518500249+rdi*1+r14]
add edi,ecx
xor eax,esi
rol r12d,30
add edi,eax
mov ebp,DWORD[40+r9]
mov eax,r13d
mov DWORD[36+rsp],edx
mov ecx,edi
bswap ebp
xor eax,r12d
rol ecx,5
and eax,r11d
lea esi,[1518500249+rsi*1+rdx]
add esi,ecx
xor eax,r13d
rol r11d,30
add esi,eax
mov r14d,DWORD[44+r9]
mov eax,r12d
mov DWORD[40+rsp],ebp
mov ecx,esi
bswap r14d
xor eax,r11d
rol ecx,5
and eax,edi
lea r13d,[1518500249+r13*1+rbp]
add r13d,ecx
xor eax,r12d
rol edi,30
add r13d,eax
mov edx,DWORD[48+r9]
mov eax,r11d
mov DWORD[44+rsp],r14d
mov ecx,r13d
bswap edx
xor eax,edi
rol ecx,5
and eax,esi
lea r12d,[1518500249+r12*1+r14]
add r12d,ecx
xor eax,r11d
rol esi,30
add r12d,eax
mov ebp,DWORD[52+r9]
mov eax,edi
mov DWORD[48+rsp],edx
mov ecx,r12d
bswap ebp
xor eax,esi
rol ecx,5
and eax,r13d
lea r11d,[1518500249+r11*1+rdx]
add r11d,ecx
xor eax,edi
rol r13d,30
add r11d,eax
mov r14d,DWORD[56+r9]
mov eax,esi
mov DWORD[52+rsp],ebp
mov ecx,r11d
bswap r14d
xor eax,r13d
rol ecx,5
and eax,r12d
lea edi,[1518500249+rdi*1+rbp]
add edi,ecx
xor eax,esi
rol r12d,30
add edi,eax
mov edx,DWORD[60+r9]
mov eax,r13d
mov DWORD[56+rsp],r14d
mov ecx,edi
bswap edx
xor eax,r12d
rol ecx,5
and eax,r11d
lea esi,[1518500249+rsi*1+r14]
add esi,ecx
xor eax,r13d
rol r11d,30
add esi,eax
xor ebp,DWORD[rsp]
mov eax,r12d
mov DWORD[60+rsp],edx
mov ecx,esi
xor ebp,DWORD[8+rsp]
xor eax,r11d
rol ecx,5
xor ebp,DWORD[32+rsp]
and eax,edi
lea r13d,[1518500249+r13*1+rdx]
rol edi,30
xor eax,r12d
add r13d,ecx
rol ebp,1
add r13d,eax
xor r14d,DWORD[4+rsp]
mov eax,r11d
mov DWORD[rsp],ebp
mov ecx,r13d
xor r14d,DWORD[12+rsp]
xor eax,edi
rol ecx,5
xor r14d,DWORD[36+rsp]
and eax,esi
lea r12d,[1518500249+r12*1+rbp]
rol esi,30
xor eax,r11d
add r12d,ecx
rol r14d,1
add r12d,eax
xor edx,DWORD[8+rsp]
mov eax,edi
mov DWORD[4+rsp],r14d
mov ecx,r12d
xor edx,DWORD[16+rsp]
xor eax,esi
rol ecx,5
xor edx,DWORD[40+rsp]
and eax,r13d
lea r11d,[1518500249+r11*1+r14]
rol r13d,30
xor eax,edi
add r11d,ecx
rol edx,1
add r11d,eax
xor ebp,DWORD[12+rsp]
mov eax,esi
mov DWORD[8+rsp],edx
mov ecx,r11d
xor ebp,DWORD[20+rsp]
xor eax,r13d
rol ecx,5
xor ebp,DWORD[44+rsp]
and eax,r12d
lea edi,[1518500249+rdi*1+rdx]
rol r12d,30
xor eax,esi
add edi,ecx
rol ebp,1
add edi,eax
xor r14d,DWORD[16+rsp]
mov eax,r13d
mov DWORD[12+rsp],ebp
mov ecx,edi
xor r14d,DWORD[24+rsp]
xor eax,r12d
rol ecx,5
xor r14d,DWORD[48+rsp]
and eax,r11d
lea esi,[1518500249+rsi*1+rbp]
rol r11d,30
xor eax,r13d
add esi,ecx
rol r14d,1
add esi,eax
xor edx,DWORD[20+rsp]
mov eax,edi
mov DWORD[16+rsp],r14d
mov ecx,esi
xor edx,DWORD[28+rsp]
xor eax,r12d
rol ecx,5
xor edx,DWORD[52+rsp]
lea r13d,[1859775393+r13*1+r14]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol edx,1
xor ebp,DWORD[24+rsp]
mov eax,esi
mov DWORD[20+rsp],edx
mov ecx,r13d
xor ebp,DWORD[32+rsp]
xor eax,r11d
rol ecx,5
xor ebp,DWORD[56+rsp]
lea r12d,[1859775393+r12*1+rdx]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol ebp,1
xor r14d,DWORD[28+rsp]
mov eax,r13d
mov DWORD[24+rsp],ebp
mov ecx,r12d
xor r14d,DWORD[36+rsp]
xor eax,edi
rol ecx,5
xor r14d,DWORD[60+rsp]
lea r11d,[1859775393+r11*1+rbp]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol r14d,1
xor edx,DWORD[32+rsp]
mov eax,r12d
mov DWORD[28+rsp],r14d
mov ecx,r11d
xor edx,DWORD[40+rsp]
xor eax,esi
rol ecx,5
xor edx,DWORD[rsp]
lea edi,[1859775393+rdi*1+r14]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol edx,1
xor ebp,DWORD[36+rsp]
mov eax,r11d
mov DWORD[32+rsp],edx
mov ecx,edi
xor ebp,DWORD[44+rsp]
xor eax,r13d
rol ecx,5
xor ebp,DWORD[4+rsp]
lea esi,[1859775393+rsi*1+rdx]
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
rol ebp,1
xor r14d,DWORD[40+rsp]
mov eax,edi
mov DWORD[36+rsp],ebp
mov ecx,esi
xor r14d,DWORD[48+rsp]
xor eax,r12d
rol ecx,5
xor r14d,DWORD[8+rsp]
lea r13d,[1859775393+r13*1+rbp]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol r14d,1
xor edx,DWORD[44+rsp]
mov eax,esi
mov DWORD[40+rsp],r14d
mov ecx,r13d
xor edx,DWORD[52+rsp]
xor eax,r11d
rol ecx,5
xor edx,DWORD[12+rsp]
lea r12d,[1859775393+r12*1+r14]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol edx,1
xor ebp,DWORD[48+rsp]
mov eax,r13d
mov DWORD[44+rsp],edx
mov ecx,r12d
xor ebp,DWORD[56+rsp]
xor eax,edi
rol ecx,5
xor ebp,DWORD[16+rsp]
lea r11d,[1859775393+r11*1+rdx]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol ebp,1
xor r14d,DWORD[52+rsp]
mov eax,r12d
mov DWORD[48+rsp],ebp
mov ecx,r11d
xor r14d,DWORD[60+rsp]
xor eax,esi
rol ecx,5
xor r14d,DWORD[20+rsp]
lea edi,[1859775393+rdi*1+rbp]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol r14d,1
xor edx,DWORD[56+rsp]
mov eax,r11d
mov DWORD[52+rsp],r14d
mov ecx,edi
xor edx,DWORD[rsp]
xor eax,r13d
rol ecx,5
xor edx,DWORD[24+rsp]
lea esi,[1859775393+rsi*1+r14]
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
rol edx,1
xor ebp,DWORD[60+rsp]
mov eax,edi
mov DWORD[56+rsp],edx
mov ecx,esi
xor ebp,DWORD[4+rsp]
xor eax,r12d
rol ecx,5
xor ebp,DWORD[28+rsp]
lea r13d,[1859775393+r13*1+rdx]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol ebp,1
xor r14d,DWORD[rsp]
mov eax,esi
mov DWORD[60+rsp],ebp
mov ecx,r13d
xor r14d,DWORD[8+rsp]
xor eax,r11d
rol ecx,5
xor r14d,DWORD[32+rsp]
lea r12d,[1859775393+r12*1+rbp]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol r14d,1
xor edx,DWORD[4+rsp]
mov eax,r13d
mov DWORD[rsp],r14d
mov ecx,r12d
xor edx,DWORD[12+rsp]
xor eax,edi
rol ecx,5
xor edx,DWORD[36+rsp]
lea r11d,[1859775393+r11*1+r14]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol edx,1
xor ebp,DWORD[8+rsp]
mov eax,r12d
mov DWORD[4+rsp],edx
mov ecx,r11d
xor ebp,DWORD[16+rsp]
xor eax,esi
rol ecx,5
xor ebp,DWORD[40+rsp]
lea edi,[1859775393+rdi*1+rdx]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol ebp,1
xor r14d,DWORD[12+rsp]
mov eax,r11d
mov DWORD[8+rsp],ebp
mov ecx,edi
xor r14d,DWORD[20+rsp]
xor eax,r13d
rol ecx,5
xor r14d,DWORD[44+rsp]
lea esi,[1859775393+rsi*1+rbp]
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
rol r14d,1
xor edx,DWORD[16+rsp]
mov eax,edi
mov DWORD[12+rsp],r14d
mov ecx,esi
xor edx,DWORD[24+rsp]
xor eax,r12d
rol ecx,5
xor edx,DWORD[48+rsp]
lea r13d,[1859775393+r13*1+r14]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol edx,1
xor ebp,DWORD[20+rsp]
mov eax,esi
mov DWORD[16+rsp],edx
mov ecx,r13d
xor ebp,DWORD[28+rsp]
xor eax,r11d
rol ecx,5
xor ebp,DWORD[52+rsp]
lea r12d,[1859775393+r12*1+rdx]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol ebp,1
xor r14d,DWORD[24+rsp]
mov eax,r13d
mov DWORD[20+rsp],ebp
mov ecx,r12d
xor r14d,DWORD[32+rsp]
xor eax,edi
rol ecx,5
xor r14d,DWORD[56+rsp]
lea r11d,[1859775393+r11*1+rbp]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol r14d,1
xor edx,DWORD[28+rsp]
mov eax,r12d
mov DWORD[24+rsp],r14d
mov ecx,r11d
xor edx,DWORD[36+rsp]
xor eax,esi
rol ecx,5
xor edx,DWORD[60+rsp]
lea edi,[1859775393+rdi*1+r14]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol edx,1
xor ebp,DWORD[32+rsp]
mov eax,r11d
mov DWORD[28+rsp],edx
mov ecx,edi
xor ebp,DWORD[40+rsp]
xor eax,r13d
rol ecx,5
xor ebp,DWORD[rsp]
lea esi,[1859775393+rsi*1+rdx]
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
rol ebp,1
xor r14d,DWORD[36+rsp]
mov eax,r12d
mov DWORD[32+rsp],ebp
mov ebx,r12d
xor r14d,DWORD[44+rsp]
and eax,r11d
mov ecx,esi
xor r14d,DWORD[4+rsp]
lea r13d,[((-1894007588))+r13*1+rbp]
xor ebx,r11d
rol ecx,5
add r13d,eax
rol r14d,1
and ebx,edi
add r13d,ecx
rol edi,30
add r13d,ebx
xor edx,DWORD[40+rsp]
mov eax,r11d
mov DWORD[36+rsp],r14d
mov ebx,r11d
xor edx,DWORD[48+rsp]
and eax,edi
mov ecx,r13d
xor edx,DWORD[8+rsp]
lea r12d,[((-1894007588))+r12*1+r14]
xor ebx,edi
rol ecx,5
add r12d,eax
rol edx,1
and ebx,esi
add r12d,ecx
rol esi,30
add r12d,ebx
xor ebp,DWORD[44+rsp]
mov eax,edi
mov DWORD[40+rsp],edx
mov ebx,edi
xor ebp,DWORD[52+rsp]
and eax,esi
mov ecx,r12d
xor ebp,DWORD[12+rsp]
lea r11d,[((-1894007588))+r11*1+rdx]
xor ebx,esi
rol ecx,5
add r11d,eax
rol ebp,1
and ebx,r13d
add r11d,ecx
rol r13d,30
add r11d,ebx
xor r14d,DWORD[48+rsp]
mov eax,esi
mov DWORD[44+rsp],ebp
mov ebx,esi
xor r14d,DWORD[56+rsp]
and eax,r13d
mov ecx,r11d
xor r14d,DWORD[16+rsp]
lea edi,[((-1894007588))+rdi*1+rbp]
xor ebx,r13d
rol ecx,5
add edi,eax
rol r14d,1
and ebx,r12d
add edi,ecx
rol r12d,30
add edi,ebx
xor edx,DWORD[52+rsp]
mov eax,r13d
mov DWORD[48+rsp],r14d
mov ebx,r13d
xor edx,DWORD[60+rsp]
and eax,r12d
mov ecx,edi
xor edx,DWORD[20+rsp]
lea esi,[((-1894007588))+rsi*1+r14]
xor ebx,r12d
rol ecx,5
add esi,eax
rol edx,1
and ebx,r11d
add esi,ecx
rol r11d,30
add esi,ebx
xor ebp,DWORD[56+rsp]
mov eax,r12d
mov DWORD[52+rsp],edx
mov ebx,r12d
xor ebp,DWORD[rsp]
and eax,r11d
mov ecx,esi
xor ebp,DWORD[24+rsp]
lea r13d,[((-1894007588))+r13*1+rdx]
xor ebx,r11d
rol ecx,5
add r13d,eax
rol ebp,1
and ebx,edi
add r13d,ecx
rol edi,30
add r13d,ebx
xor r14d,DWORD[60+rsp]
mov eax,r11d
mov DWORD[56+rsp],ebp
mov ebx,r11d
xor r14d,DWORD[4+rsp]
and eax,edi
mov ecx,r13d
xor r14d,DWORD[28+rsp]
lea r12d,[((-1894007588))+r12*1+rbp]
xor ebx,edi
rol ecx,5
add r12d,eax
rol r14d,1
and ebx,esi
add r12d,ecx
rol esi,30
add r12d,ebx
xor edx,DWORD[rsp]
mov eax,edi
mov DWORD[60+rsp],r14d
mov ebx,edi
xor edx,DWORD[8+rsp]
and eax,esi
mov ecx,r12d
xor edx,DWORD[32+rsp]
lea r11d,[((-1894007588))+r11*1+r14]
xor ebx,esi
rol ecx,5
add r11d,eax
rol edx,1
and ebx,r13d
add r11d,ecx
rol r13d,30
add r11d,ebx
xor ebp,DWORD[4+rsp]
mov eax,esi
mov DWORD[rsp],edx
mov ebx,esi
xor ebp,DWORD[12+rsp]
and eax,r13d
mov ecx,r11d
xor ebp,DWORD[36+rsp]
lea edi,[((-1894007588))+rdi*1+rdx]
xor ebx,r13d
rol ecx,5
add edi,eax
rol ebp,1
and ebx,r12d
add edi,ecx
rol r12d,30
add edi,ebx
xor r14d,DWORD[8+rsp]
mov eax,r13d
mov DWORD[4+rsp],ebp
mov ebx,r13d
xor r14d,DWORD[16+rsp]
and eax,r12d
mov ecx,edi
xor r14d,DWORD[40+rsp]
lea esi,[((-1894007588))+rsi*1+rbp]
xor ebx,r12d
rol ecx,5
add esi,eax
rol r14d,1
and ebx,r11d
add esi,ecx
rol r11d,30
add esi,ebx
xor edx,DWORD[12+rsp]
mov eax,r12d
mov DWORD[8+rsp],r14d
mov ebx,r12d
xor edx,DWORD[20+rsp]
and eax,r11d
mov ecx,esi
xor edx,DWORD[44+rsp]
lea r13d,[((-1894007588))+r13*1+r14]
xor ebx,r11d
rol ecx,5
add r13d,eax
rol edx,1
and ebx,edi
add r13d,ecx
rol edi,30
add r13d,ebx
xor ebp,DWORD[16+rsp]
mov eax,r11d
mov DWORD[12+rsp],edx
mov ebx,r11d
xor ebp,DWORD[24+rsp]
and eax,edi
mov ecx,r13d
xor ebp,DWORD[48+rsp]
lea r12d,[((-1894007588))+r12*1+rdx]
xor ebx,edi
rol ecx,5
add r12d,eax
rol ebp,1
and ebx,esi
add r12d,ecx
rol esi,30
add r12d,ebx
xor r14d,DWORD[20+rsp]
mov eax,edi
mov DWORD[16+rsp],ebp
mov ebx,edi
xor r14d,DWORD[28+rsp]
and eax,esi
mov ecx,r12d
xor r14d,DWORD[52+rsp]
lea r11d,[((-1894007588))+r11*1+rbp]
xor ebx,esi
rol ecx,5
add r11d,eax
rol r14d,1
and ebx,r13d
add r11d,ecx
rol r13d,30
add r11d,ebx
xor edx,DWORD[24+rsp]
mov eax,esi
mov DWORD[20+rsp],r14d
mov ebx,esi
xor edx,DWORD[32+rsp]
and eax,r13d
mov ecx,r11d
xor edx,DWORD[56+rsp]
lea edi,[((-1894007588))+rdi*1+r14]
xor ebx,r13d
rol ecx,5
add edi,eax
rol edx,1
and ebx,r12d
add edi,ecx
rol r12d,30
add edi,ebx
xor ebp,DWORD[28+rsp]
mov eax,r13d
mov DWORD[24+rsp],edx
mov ebx,r13d
xor ebp,DWORD[36+rsp]
and eax,r12d
mov ecx,edi
xor ebp,DWORD[60+rsp]
lea esi,[((-1894007588))+rsi*1+rdx]
xor ebx,r12d
rol ecx,5
add esi,eax
rol ebp,1
and ebx,r11d
add esi,ecx
rol r11d,30
add esi,ebx
xor r14d,DWORD[32+rsp]
mov eax,r12d
mov DWORD[28+rsp],ebp
mov ebx,r12d
xor r14d,DWORD[40+rsp]
and eax,r11d
mov ecx,esi
xor r14d,DWORD[rsp]
lea r13d,[((-1894007588))+r13*1+rbp]
xor ebx,r11d
rol ecx,5
add r13d,eax
rol r14d,1
and ebx,edi
add r13d,ecx
rol edi,30
add r13d,ebx
xor edx,DWORD[36+rsp]
mov eax,r11d
mov DWORD[32+rsp],r14d
mov ebx,r11d
xor edx,DWORD[44+rsp]
and eax,edi
mov ecx,r13d
xor edx,DWORD[4+rsp]
lea r12d,[((-1894007588))+r12*1+r14]
xor ebx,edi
rol ecx,5
add r12d,eax
rol edx,1
and ebx,esi
add r12d,ecx
rol esi,30
add r12d,ebx
xor ebp,DWORD[40+rsp]
mov eax,edi
mov DWORD[36+rsp],edx
mov ebx,edi
xor ebp,DWORD[48+rsp]
and eax,esi
mov ecx,r12d
xor ebp,DWORD[8+rsp]
lea r11d,[((-1894007588))+r11*1+rdx]
xor ebx,esi
rol ecx,5
add r11d,eax
rol ebp,1
and ebx,r13d
add r11d,ecx
rol r13d,30
add r11d,ebx
xor r14d,DWORD[44+rsp]
mov eax,esi
mov DWORD[40+rsp],ebp
mov ebx,esi
xor r14d,DWORD[52+rsp]
and eax,r13d
mov ecx,r11d
xor r14d,DWORD[12+rsp]
lea edi,[((-1894007588))+rdi*1+rbp]
xor ebx,r13d
rol ecx,5
add edi,eax
rol r14d,1
and ebx,r12d
add edi,ecx
rol r12d,30
add edi,ebx
xor edx,DWORD[48+rsp]
mov eax,r13d
mov DWORD[44+rsp],r14d
mov ebx,r13d
xor edx,DWORD[56+rsp]
and eax,r12d
mov ecx,edi
xor edx,DWORD[16+rsp]
lea esi,[((-1894007588))+rsi*1+r14]
xor ebx,r12d
rol ecx,5
add esi,eax
rol edx,1
and ebx,r11d
add esi,ecx
rol r11d,30
add esi,ebx
xor ebp,DWORD[52+rsp]
mov eax,edi
mov DWORD[48+rsp],edx
mov ecx,esi
xor ebp,DWORD[60+rsp]
xor eax,r12d
rol ecx,5
xor ebp,DWORD[20+rsp]
lea r13d,[((-899497514))+r13*1+rdx]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol ebp,1
xor r14d,DWORD[56+rsp]
mov eax,esi
mov DWORD[52+rsp],ebp
mov ecx,r13d
xor r14d,DWORD[rsp]
xor eax,r11d
rol ecx,5
xor r14d,DWORD[24+rsp]
lea r12d,[((-899497514))+r12*1+rbp]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol r14d,1
xor edx,DWORD[60+rsp]
mov eax,r13d
mov DWORD[56+rsp],r14d
mov ecx,r12d
xor edx,DWORD[4+rsp]
xor eax,edi
rol ecx,5
xor edx,DWORD[28+rsp]
lea r11d,[((-899497514))+r11*1+r14]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol edx,1
xor ebp,DWORD[rsp]
mov eax,r12d
mov DWORD[60+rsp],edx
mov ecx,r11d
xor ebp,DWORD[8+rsp]
xor eax,esi
rol ecx,5
xor ebp,DWORD[32+rsp]
lea edi,[((-899497514))+rdi*1+rdx]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol ebp,1
xor r14d,DWORD[4+rsp]
mov eax,r11d
mov DWORD[rsp],ebp
mov ecx,edi
xor r14d,DWORD[12+rsp]
xor eax,r13d
rol ecx,5
xor r14d,DWORD[36+rsp]
lea esi,[((-899497514))+rsi*1+rbp]
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
rol r14d,1
xor edx,DWORD[8+rsp]
mov eax,edi
mov DWORD[4+rsp],r14d
mov ecx,esi
xor edx,DWORD[16+rsp]
xor eax,r12d
rol ecx,5
xor edx,DWORD[40+rsp]
lea r13d,[((-899497514))+r13*1+r14]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol edx,1
xor ebp,DWORD[12+rsp]
mov eax,esi
mov DWORD[8+rsp],edx
mov ecx,r13d
xor ebp,DWORD[20+rsp]
xor eax,r11d
rol ecx,5
xor ebp,DWORD[44+rsp]
lea r12d,[((-899497514))+r12*1+rdx]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol ebp,1
xor r14d,DWORD[16+rsp]
mov eax,r13d
mov DWORD[12+rsp],ebp
mov ecx,r12d
xor r14d,DWORD[24+rsp]
xor eax,edi
rol ecx,5
xor r14d,DWORD[48+rsp]
lea r11d,[((-899497514))+r11*1+rbp]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol r14d,1
xor edx,DWORD[20+rsp]
mov eax,r12d
mov DWORD[16+rsp],r14d
mov ecx,r11d
xor edx,DWORD[28+rsp]
xor eax,esi
rol ecx,5
xor edx,DWORD[52+rsp]
lea edi,[((-899497514))+rdi*1+r14]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol edx,1
xor ebp,DWORD[24+rsp]
mov eax,r11d
mov DWORD[20+rsp],edx
mov ecx,edi
xor ebp,DWORD[32+rsp]
xor eax,r13d
rol ecx,5
xor ebp,DWORD[56+rsp]
lea esi,[((-899497514))+rsi*1+rdx]
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
rol ebp,1
xor r14d,DWORD[28+rsp]
mov eax,edi
mov DWORD[24+rsp],ebp
mov ecx,esi
xor r14d,DWORD[36+rsp]
xor eax,r12d
rol ecx,5
xor r14d,DWORD[60+rsp]
lea r13d,[((-899497514))+r13*1+rbp]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol r14d,1
xor edx,DWORD[32+rsp]
mov eax,esi
mov DWORD[28+rsp],r14d
mov ecx,r13d
xor edx,DWORD[40+rsp]
xor eax,r11d
rol ecx,5
xor edx,DWORD[rsp]
lea r12d,[((-899497514))+r12*1+r14]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol edx,1
xor ebp,DWORD[36+rsp]
mov eax,r13d
mov ecx,r12d
xor ebp,DWORD[44+rsp]
xor eax,edi
rol ecx,5
xor ebp,DWORD[4+rsp]
lea r11d,[((-899497514))+r11*1+rdx]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol ebp,1
xor r14d,DWORD[40+rsp]
mov eax,r12d
mov ecx,r11d
xor r14d,DWORD[48+rsp]
xor eax,esi
rol ecx,5
xor r14d,DWORD[8+rsp]
lea edi,[((-899497514))+rdi*1+rbp]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol r14d,1
xor edx,DWORD[44+rsp]
mov eax,r11d
mov ecx,edi
xor edx,DWORD[52+rsp]
xor eax,r13d
rol ecx,5
xor edx,DWORD[12+rsp]
lea esi,[((-899497514))+rsi*1+r14]
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
rol edx,1
xor ebp,DWORD[48+rsp]
mov eax,edi
mov ecx,esi
xor ebp,DWORD[56+rsp]
xor eax,r12d
rol ecx,5
xor ebp,DWORD[16+rsp]
lea r13d,[((-899497514))+r13*1+rdx]
xor eax,r11d
add r13d,ecx
rol edi,30
add r13d,eax
rol ebp,1
xor r14d,DWORD[52+rsp]
mov eax,esi
mov ecx,r13d
xor r14d,DWORD[60+rsp]
xor eax,r11d
rol ecx,5
xor r14d,DWORD[20+rsp]
lea r12d,[((-899497514))+r12*1+rbp]
xor eax,edi
add r12d,ecx
rol esi,30
add r12d,eax
rol r14d,1
xor edx,DWORD[56+rsp]
mov eax,r13d
mov ecx,r12d
xor edx,DWORD[rsp]
xor eax,edi
rol ecx,5
xor edx,DWORD[24+rsp]
lea r11d,[((-899497514))+r11*1+r14]
xor eax,esi
add r11d,ecx
rol r13d,30
add r11d,eax
rol edx,1
xor ebp,DWORD[60+rsp]
mov eax,r12d
mov ecx,r11d
xor ebp,DWORD[4+rsp]
xor eax,esi
rol ecx,5
xor ebp,DWORD[28+rsp]
lea edi,[((-899497514))+rdi*1+rdx]
xor eax,r13d
add edi,ecx
rol r12d,30
add edi,eax
rol ebp,1
mov eax,r11d
mov ecx,edi
xor eax,r13d
lea esi,[((-899497514))+rsi*1+rbp]
rol ecx,5
xor eax,r12d
add esi,ecx
rol r11d,30
add esi,eax
add esi,DWORD[r8]
add edi,DWORD[4+r8]
add r11d,DWORD[8+r8]
add r12d,DWORD[12+r8]
add r13d,DWORD[16+r8]
mov DWORD[r8],esi
mov DWORD[4+r8],edi
mov DWORD[8+r8],r11d
mov DWORD[12+r8],r12d
mov DWORD[16+r8],r13d
sub r10,1
lea r9,[64+r9]
jnz NEAR $L$loop
mov rsi,QWORD[64+rsp]
mov r14,QWORD[((-40))+rsi]
mov r13,QWORD[((-32))+rsi]
mov r12,QWORD[((-24))+rsi]
mov rbp,QWORD[((-16))+rsi]
mov rbx,QWORD[((-8))+rsi]
lea rsp,[rsi]
$L$epilogue:
mov rdi,QWORD[8+rsp] ;WIN64 epilogue
mov rsi,QWORD[16+rsp]
ret
$L$SEH_end_sha1_block_data_order_nohw:
global sha1_block_data_order_hw
ALIGN 32
sha1_block_data_order_hw:
mov QWORD[8+rsp],rdi ;WIN64 prologue
mov QWORD[16+rsp],rsi
mov rax,rsp
$L$SEH_begin_sha1_block_data_order_hw:
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
_CET_ENDBR
lea rsp,[((-72))+rsp]
movaps XMMWORD[(-8-64)+rax],xmm6
movaps XMMWORD[(-8-48)+rax],xmm7
movaps XMMWORD[(-8-32)+rax],xmm8
movaps XMMWORD[(-8-16)+rax],xmm9
$L$prologue_shaext:
movdqu xmm0,XMMWORD[rdi]
movd xmm1,DWORD[16+rdi]
movdqa xmm3,XMMWORD[((K_XX_XX+160))]
movdqu xmm4,XMMWORD[rsi]
pshufd xmm0,xmm0,27
movdqu xmm5,XMMWORD[16+rsi]
pshufd xmm1,xmm1,27
movdqu xmm6,XMMWORD[32+rsi]
DB 102,15,56,0,227
movdqu xmm7,XMMWORD[48+rsi]
DB 102,15,56,0,235
DB 102,15,56,0,243
movdqa xmm9,xmm1
DB 102,15,56,0,251
jmp NEAR $L$oop_shaext
ALIGN 16
$L$oop_shaext:
dec rdx
lea r8,[64+rsi]
paddd xmm1,xmm4
cmovne rsi,r8
prefetcht0 [512+rsi]
movdqa xmm8,xmm0
DB 15,56,201,229
movdqa xmm2,xmm0
DB 15,58,204,193,0
DB 15,56,200,213
pxor xmm4,xmm6
DB 15,56,201,238
DB 15,56,202,231
movdqa xmm1,xmm0
DB 15,58,204,194,0
DB 15,56,200,206
pxor xmm5,xmm7
DB 15,56,202,236
DB 15,56,201,247
movdqa xmm2,xmm0
DB 15,58,204,193,0
DB 15,56,200,215
pxor xmm6,xmm4
DB 15,56,201,252
DB 15,56,202,245
movdqa xmm1,xmm0
DB 15,58,204,194,0
DB 15,56,200,204
pxor xmm7,xmm5
DB 15,56,202,254
DB 15,56,201,229
movdqa xmm2,xmm0
DB 15,58,204,193,0
DB 15,56,200,213
pxor xmm4,xmm6
DB 15,56,201,238
DB 15,56,202,231
movdqa xmm1,xmm0
DB 15,58,204,194,1
DB 15,56,200,206
pxor xmm5,xmm7
DB 15,56,202,236
DB 15,56,201,247
movdqa xmm2,xmm0
DB 15,58,204,193,1
DB 15,56,200,215
pxor xmm6,xmm4
DB 15,56,201,252
DB 15,56,202,245
movdqa xmm1,xmm0
DB 15,58,204,194,1
DB 15,56,200,204
pxor xmm7,xmm5
DB 15,56,202,254
DB 15,56,201,229
movdqa xmm2,xmm0
DB 15,58,204,193,1
DB 15,56,200,213
pxor xmm4,xmm6
DB 15,56,201,238
DB 15,56,202,231
movdqa xmm1,xmm0
DB 15,58,204,194,1
DB 15,56,200,206
pxor xmm5,xmm7
DB 15,56,202,236
DB 15,56,201,247
movdqa xmm2,xmm0
DB 15,58,204,193,2
DB 15,56,200,215
pxor xmm6,xmm4
DB 15,56,201,252
DB 15,56,202,245
movdqa xmm1,xmm0
DB 15,58,204,194,2
DB 15,56,200,204
pxor xmm7,xmm5
DB 15,56,202,254
DB 15,56,201,229
movdqa xmm2,xmm0
DB 15,58,204,193,2
DB 15,56,200,213
pxor xmm4,xmm6
DB 15,56,201,238
DB 15,56,202,231
movdqa xmm1,xmm0
DB 15,58,204,194,2
DB 15,56,200,206
pxor xmm5,xmm7
DB 15,56,202,236
DB 15,56,201,247
movdqa xmm2,xmm0
DB 15,58,204,193,2
DB 15,56,200,215
pxor xmm6,xmm4
DB 15,56,201,252
DB 15,56,202,245
movdqa xmm1,xmm0
DB 15,58,204,194,3
DB 15,56,200,204
pxor xmm7,xmm5
DB 15,56,202,254
movdqu xmm4,XMMWORD[rsi]
movdqa xmm2,xmm0
DB 15,58,204,193,3
DB 15,56,200,213
movdqu xmm5,XMMWORD[16+rsi]
DB 102,15,56,0,227
movdqa xmm1,xmm0
DB 15,58,204,194,3
DB 15,56,200,206
movdqu xmm6,XMMWORD[32+rsi]
DB 102,15,56,0,235
movdqa xmm2,xmm0
DB 15,58,204,193,3
DB 15,56,200,215
movdqu xmm7,XMMWORD[48+rsi]
DB 102,15,56,0,243
movdqa xmm1,xmm0
DB 15,58,204,194,3
DB 65,15,56,200,201
DB 102,15,56,0,251
paddd xmm0,xmm8
movdqa xmm9,xmm1
jnz NEAR $L$oop_shaext
pshufd xmm0,xmm0,27
pshufd xmm1,xmm1,27
movdqu XMMWORD[rdi],xmm0
movd DWORD[16+rdi],xmm1
movaps xmm6,XMMWORD[((-8-64))+rax]
movaps xmm7,XMMWORD[((-8-48))+rax]
movaps xmm8,XMMWORD[((-8-32))+rax]
movaps xmm9,XMMWORD[((-8-16))+rax]
mov rsp,rax
$L$epilogue_shaext:
mov rdi,QWORD[8+rsp] ;WIN64 epilogue
mov rsi,QWORD[16+rsp]
ret
$L$SEH_end_sha1_block_data_order_hw:
global sha1_block_data_order_ssse3
ALIGN 16
sha1_block_data_order_ssse3:
mov QWORD[8+rsp],rdi ;WIN64 prologue
mov QWORD[16+rsp],rsi
mov rax,rsp
$L$SEH_begin_sha1_block_data_order_ssse3:
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
_CET_ENDBR
mov r11,rsp
push rbx
push rbp
push r12
push r13
push r14
lea rsp,[((-160))+rsp]
movaps XMMWORD[(-40-96)+r11],xmm6
movaps XMMWORD[(-40-80)+r11],xmm7
movaps XMMWORD[(-40-64)+r11],xmm8
movaps XMMWORD[(-40-48)+r11],xmm9
movaps XMMWORD[(-40-32)+r11],xmm10
movaps XMMWORD[(-40-16)+r11],xmm11
$L$prologue_ssse3:
and rsp,-64
mov r8,rdi
mov r9,rsi
mov r10,rdx
shl r10,6
add r10,r9
lea r14,[((K_XX_XX+64))]
mov eax,DWORD[r8]
mov ebx,DWORD[4+r8]
mov ecx,DWORD[8+r8]
mov edx,DWORD[12+r8]
mov esi,ebx
mov ebp,DWORD[16+r8]
mov edi,ecx
xor edi,edx
and esi,edi
movdqa xmm6,XMMWORD[64+r14]
movdqa xmm9,XMMWORD[((-64))+r14]
movdqu xmm0,XMMWORD[r9]
movdqu xmm1,XMMWORD[16+r9]
movdqu xmm2,XMMWORD[32+r9]
movdqu xmm3,XMMWORD[48+r9]
DB 102,15,56,0,198
DB 102,15,56,0,206
DB 102,15,56,0,214
add r9,64
paddd xmm0,xmm9
DB 102,15,56,0,222
paddd xmm1,xmm9
paddd xmm2,xmm9
movdqa XMMWORD[rsp],xmm0
psubd xmm0,xmm9
movdqa XMMWORD[16+rsp],xmm1
psubd xmm1,xmm9
movdqa XMMWORD[32+rsp],xmm2
psubd xmm2,xmm9
jmp NEAR $L$oop_ssse3
ALIGN 16
$L$oop_ssse3:
ror ebx,2
pshufd xmm4,xmm0,238
xor esi,edx
movdqa xmm8,xmm3
paddd xmm9,xmm3
mov edi,eax
add ebp,DWORD[rsp]
punpcklqdq xmm4,xmm1
xor ebx,ecx
rol eax,5
add ebp,esi
psrldq xmm8,4
and edi,ebx
xor ebx,ecx
pxor xmm4,xmm0
add ebp,eax
ror eax,7
pxor xmm8,xmm2
xor edi,ecx
mov esi,ebp
add edx,DWORD[4+rsp]
pxor xmm4,xmm8
xor eax,ebx
rol ebp,5
movdqa XMMWORD[48+rsp],xmm9
add edx,edi
and esi,eax
movdqa xmm10,xmm4
xor eax,ebx
add edx,ebp
ror ebp,7
movdqa xmm8,xmm4
xor esi,ebx
pslldq xmm10,12
paddd xmm4,xmm4
mov edi,edx
add ecx,DWORD[8+rsp]
psrld xmm8,31
xor ebp,eax
rol edx,5
add ecx,esi
movdqa xmm9,xmm10
and edi,ebp
xor ebp,eax
psrld xmm10,30
add ecx,edx
ror edx,7
por xmm4,xmm8
xor edi,eax
mov esi,ecx
add ebx,DWORD[12+rsp]
pslld xmm9,2
pxor xmm4,xmm10
xor edx,ebp
movdqa xmm10,XMMWORD[((-64))+r14]
rol ecx,5
add ebx,edi
and esi,edx
pxor xmm4,xmm9
xor edx,ebp
add ebx,ecx
ror ecx,7
pshufd xmm5,xmm1,238
xor esi,ebp
movdqa xmm9,xmm4
paddd xmm10,xmm4
mov edi,ebx
add eax,DWORD[16+rsp]
punpcklqdq xmm5,xmm2
xor ecx,edx
rol ebx,5
add eax,esi
psrldq xmm9,4
and edi,ecx
xor ecx,edx
pxor xmm5,xmm1
add eax,ebx
ror ebx,7
pxor xmm9,xmm3
xor edi,edx
mov esi,eax
add ebp,DWORD[20+rsp]
pxor xmm5,xmm9
xor ebx,ecx
rol eax,5
movdqa XMMWORD[rsp],xmm10
add ebp,edi
and esi,ebx
movdqa xmm8,xmm5
xor ebx,ecx
add ebp,eax
ror eax,7
movdqa xmm9,xmm5
xor esi,ecx
pslldq xmm8,12
paddd xmm5,xmm5
mov edi,ebp
add edx,DWORD[24+rsp]
psrld xmm9,31
xor eax,ebx
rol ebp,5
add edx,esi
movdqa xmm10,xmm8
and edi,eax
xor eax,ebx
psrld xmm8,30
add edx,ebp
ror ebp,7
por xmm5,xmm9
xor edi,ebx
mov esi,edx
add ecx,DWORD[28+rsp]
pslld xmm10,2
pxor xmm5,xmm8
xor ebp,eax
movdqa xmm8,XMMWORD[((-32))+r14]
rol edx,5
add ecx,edi
and esi,ebp
pxor xmm5,xmm10
xor ebp,eax
add ecx,edx
ror edx,7
pshufd xmm6,xmm2,238
xor esi,eax
movdqa xmm10,xmm5
paddd xmm8,xmm5
mov edi,ecx
add ebx,DWORD[32+rsp]
punpcklqdq xmm6,xmm3
xor edx,ebp
rol ecx,5
add ebx,esi
psrldq xmm10,4
and edi,edx
xor edx,ebp
pxor xmm6,xmm2
add ebx,ecx
ror ecx,7
pxor xmm10,xmm4
xor edi,ebp
mov esi,ebx
add eax,DWORD[36+rsp]
pxor xmm6,xmm10
xor ecx,edx
rol ebx,5
movdqa XMMWORD[16+rsp],xmm8
add eax,edi
and esi,ecx
movdqa xmm9,xmm6
xor ecx,edx
add eax,ebx
ror ebx,7
movdqa xmm10,xmm6
xor esi,edx
pslldq xmm9,12
paddd xmm6,xmm6
mov edi,eax
add ebp,DWORD[40+rsp]
psrld xmm10,31
xor ebx,ecx
rol eax,5
add ebp,esi
movdqa xmm8,xmm9
and edi,ebx
xor ebx,ecx
psrld xmm9,30
add ebp,eax
ror eax,7
por xmm6,xmm10
xor edi,ecx
mov esi,ebp
add edx,DWORD[44+rsp]
pslld xmm8,2
pxor xmm6,xmm9
xor eax,ebx
movdqa xmm9,XMMWORD[((-32))+r14]
rol ebp,5
add edx,edi
and esi,eax
pxor xmm6,xmm8
xor eax,ebx
add edx,ebp
ror ebp,7
pshufd xmm7,xmm3,238
xor esi,ebx
movdqa xmm8,xmm6
paddd xmm9,xmm6
mov edi,edx
add ecx,DWORD[48+rsp]
punpcklqdq xmm7,xmm4
xor ebp,eax
rol edx,5
add ecx,esi
psrldq xmm8,4
and edi,ebp
xor ebp,eax
pxor xmm7,xmm3
add ecx,edx
ror edx,7
pxor xmm8,xmm5
xor edi,eax
mov esi,ecx
add ebx,DWORD[52+rsp]
pxor xmm7,xmm8
xor edx,ebp
rol ecx,5
movdqa XMMWORD[32+rsp],xmm9
add ebx,edi
and esi,edx
movdqa xmm10,xmm7
xor edx,ebp
add ebx,ecx
ror ecx,7
movdqa xmm8,xmm7
xor esi,ebp
pslldq xmm10,12
paddd xmm7,xmm7
mov edi,ebx
add eax,DWORD[56+rsp]
psrld xmm8,31
xor ecx,edx
rol ebx,5
add eax,esi
movdqa xmm9,xmm10
and edi,ecx
xor ecx,edx
psrld xmm10,30
add eax,ebx
ror ebx,7
por xmm7,xmm8
xor edi,edx
mov esi,eax
add ebp,DWORD[60+rsp]
pslld xmm9,2
pxor xmm7,xmm10
xor ebx,ecx
movdqa xmm10,XMMWORD[((-32))+r14]
rol eax,5
add ebp,edi
and esi,ebx
pxor xmm7,xmm9
pshufd xmm9,xmm6,238
xor ebx,ecx
add ebp,eax
ror eax,7
pxor xmm0,xmm4
xor esi,ecx
mov edi,ebp
add edx,DWORD[rsp]
punpcklqdq xmm9,xmm7
xor eax,ebx
rol ebp,5
pxor xmm0,xmm1
add edx,esi
and edi,eax
movdqa xmm8,xmm10
xor eax,ebx
paddd xmm10,xmm7
add edx,ebp
pxor xmm0,xmm9
ror ebp,7
xor edi,ebx
mov esi,edx
add ecx,DWORD[4+rsp]
movdqa xmm9,xmm0
xor ebp,eax
rol edx,5
movdqa XMMWORD[48+rsp],xmm10
add ecx,edi
and esi,ebp
xor ebp,eax
pslld xmm0,2
add ecx,edx
ror edx,7
psrld xmm9,30
xor esi,eax
mov edi,ecx
add ebx,DWORD[8+rsp]
por xmm0,xmm9
xor edx,ebp
rol ecx,5
pshufd xmm10,xmm7,238
add ebx,esi
and edi,edx
xor edx,ebp
add ebx,ecx
add eax,DWORD[12+rsp]
xor edi,ebp
mov esi,ebx
rol ebx,5
add eax,edi
xor esi,edx
ror ecx,7
add eax,ebx
pxor xmm1,xmm5
add ebp,DWORD[16+rsp]
xor esi,ecx
punpcklqdq xmm10,xmm0
mov edi,eax
rol eax,5
pxor xmm1,xmm2
add ebp,esi
xor edi,ecx
movdqa xmm9,xmm8
ror ebx,7
paddd xmm8,xmm0
add ebp,eax
pxor xmm1,xmm10
add edx,DWORD[20+rsp]
xor edi,ebx
mov esi,ebp
rol ebp,5
movdqa xmm10,xmm1
add edx,edi
xor esi,ebx
movdqa XMMWORD[rsp],xmm8
ror eax,7
add edx,ebp
add ecx,DWORD[24+rsp]
pslld xmm1,2
xor esi,eax
mov edi,edx
psrld xmm10,30
rol edx,5
add ecx,esi
xor edi,eax
ror ebp,7
por xmm1,xmm10
add ecx,edx
add ebx,DWORD[28+rsp]
pshufd xmm8,xmm0,238
xor edi,ebp
mov esi,ecx
rol ecx,5
add ebx,edi
xor esi,ebp
ror edx,7
add ebx,ecx
pxor xmm2,xmm6
add eax,DWORD[32+rsp]
xor esi,edx
punpcklqdq xmm8,xmm1
mov edi,ebx
rol ebx,5
pxor xmm2,xmm3
add eax,esi
xor edi,edx
movdqa xmm10,XMMWORD[r14]
ror ecx,7
paddd xmm9,xmm1
add eax,ebx
pxor xmm2,xmm8
add ebp,DWORD[36+rsp]
xor edi,ecx
mov esi,eax
rol eax,5
movdqa xmm8,xmm2
add ebp,edi
xor esi,ecx
movdqa XMMWORD[16+rsp],xmm9
ror ebx,7
add ebp,eax
add edx,DWORD[40+rsp]
pslld xmm2,2
xor esi,ebx
mov edi,ebp
psrld xmm8,30
rol ebp,5
add edx,esi
xor edi,ebx
ror eax,7
por xmm2,xmm8
add edx,ebp
add ecx,DWORD[44+rsp]
pshufd xmm9,xmm1,238
xor edi,eax
mov esi,edx
rol edx,5
add ecx,edi
xor esi,eax
ror ebp,7
add ecx,edx
pxor xmm3,xmm7
add ebx,DWORD[48+rsp]
xor esi,ebp
punpcklqdq xmm9,xmm2
mov edi,ecx
rol ecx,5
pxor xmm3,xmm4
add ebx,esi
xor edi,ebp
movdqa xmm8,xmm10
ror edx,7
paddd xmm10,xmm2
add ebx,ecx
pxor xmm3,xmm9
add eax,DWORD[52+rsp]
xor edi,edx
mov esi,ebx
rol ebx,5
movdqa xmm9,xmm3
add eax,edi
xor esi,edx
movdqa XMMWORD[32+rsp],xmm10
ror ecx,7
add eax,ebx
add ebp,DWORD[56+rsp]
pslld xmm3,2
xor esi,ecx
mov edi,eax
psrld xmm9,30
rol eax,5
add ebp,esi
xor edi,ecx
ror ebx,7
por xmm3,xmm9
add ebp,eax
add edx,DWORD[60+rsp]
pshufd xmm10,xmm2,238
xor edi,ebx
mov esi,ebp
rol ebp,5
add edx,edi
xor esi,ebx
ror eax,7
add edx,ebp
pxor xmm4,xmm0
add ecx,DWORD[rsp]
xor esi,eax
punpcklqdq xmm10,xmm3
mov edi,edx
rol edx,5
pxor xmm4,xmm5
add ecx,esi
xor edi,eax
movdqa xmm9,xmm8
ror ebp,7
paddd xmm8,xmm3
add ecx,edx
pxor xmm4,xmm10
add ebx,DWORD[4+rsp]
xor edi,ebp
mov esi,ecx
rol ecx,5
movdqa xmm10,xmm4
add ebx,edi
xor esi,ebp
movdqa XMMWORD[48+rsp],xmm8
ror edx,7
add ebx,ecx
add eax,DWORD[8+rsp]
pslld xmm4,2
xor esi,edx
mov edi,ebx
psrld xmm10,30
rol ebx,5
add eax,esi
xor edi,edx
ror ecx,7
por xmm4,xmm10
add eax,ebx
add ebp,DWORD[12+rsp]
pshufd xmm8,xmm3,238
xor edi,ecx
mov esi,eax
rol eax,5
add ebp,edi
xor esi,ecx
ror ebx,7
add ebp,eax
pxor xmm5,xmm1
add edx,DWORD[16+rsp]
xor esi,ebx
punpcklqdq xmm8,xmm4
mov edi,ebp
rol ebp,5
pxor xmm5,xmm6
add edx,esi
xor edi,ebx
movdqa xmm10,xmm9
ror eax,7
paddd xmm9,xmm4
add edx,ebp
pxor xmm5,xmm8
add ecx,DWORD[20+rsp]
xor edi,eax
mov esi,edx
rol edx,5
movdqa xmm8,xmm5
add ecx,edi
xor esi,eax
movdqa XMMWORD[rsp],xmm9
ror ebp,7
add ecx,edx
add ebx,DWORD[24+rsp]
pslld xmm5,2
xor esi,ebp
mov edi,ecx
psrld xmm8,30
rol ecx,5
add ebx,esi
xor edi,ebp
ror edx,7
por xmm5,xmm8
add ebx,ecx
add eax,DWORD[28+rsp]
pshufd xmm9,xmm4,238
ror ecx,7
mov esi,ebx
xor edi,edx
rol ebx,5
add eax,edi
xor esi,ecx
xor ecx,edx
add eax,ebx
pxor xmm6,xmm2
add ebp,DWORD[32+rsp]
and esi,ecx
xor ecx,edx
ror ebx,7
punpcklqdq xmm9,xmm5
mov edi,eax
xor esi,ecx
pxor xmm6,xmm7
rol eax,5
add ebp,esi
movdqa xmm8,xmm10
xor edi,ebx
paddd xmm10,xmm5
xor ebx,ecx
pxor xmm6,xmm9
add ebp,eax
add edx,DWORD[36+rsp]
and edi,ebx
xor ebx,ecx
ror eax,7
movdqa xmm9,xmm6
mov esi,ebp
xor edi,ebx
movdqa XMMWORD[16+rsp],xmm10
rol ebp,5
add edx,edi
xor esi,eax
pslld xmm6,2
xor eax,ebx
add edx,ebp
psrld xmm9,30
add ecx,DWORD[40+rsp]
and esi,eax
xor eax,ebx
por xmm6,xmm9
ror ebp,7
mov edi,edx
xor esi,eax
rol edx,5
pshufd xmm10,xmm5,238
add ecx,esi
xor edi,ebp
xor ebp,eax
add ecx,edx
add ebx,DWORD[44+rsp]
and edi,ebp
xor ebp,eax
ror edx,7
mov esi,ecx
xor edi,ebp
rol ecx,5
add ebx,edi
xor esi,edx
xor edx,ebp
add ebx,ecx
pxor xmm7,xmm3
add eax,DWORD[48+rsp]
and esi,edx
xor edx,ebp
ror ecx,7
punpcklqdq xmm10,xmm6
mov edi,ebx
xor esi,edx
pxor xmm7,xmm0
rol ebx,5
add eax,esi
movdqa xmm9,XMMWORD[32+r14]
xor edi,ecx
paddd xmm8,xmm6
xor ecx,edx
pxor xmm7,xmm10
add eax,ebx
add ebp,DWORD[52+rsp]
and edi,ecx
xor ecx,edx
ror ebx,7
movdqa xmm10,xmm7
mov esi,eax
xor edi,ecx
movdqa XMMWORD[32+rsp],xmm8
rol eax,5
add ebp,edi
xor esi,ebx
pslld xmm7,2
xor ebx,ecx
add ebp,eax
psrld xmm10,30
add edx,DWORD[56+rsp]
and esi,ebx
xor ebx,ecx
por xmm7,xmm10
ror eax,7
mov edi,ebp
xor esi,ebx
rol ebp,5
pshufd xmm8,xmm6,238
add edx,esi
xor edi,eax
xor eax,ebx
add edx,ebp
add ecx,DWORD[60+rsp]
and edi,eax
xor eax,ebx
ror ebp,7
mov esi,edx
xor edi,eax
rol edx,5
add ecx,edi
xor esi,ebp
xor ebp,eax
add ecx,edx
pxor xmm0,xmm4
add ebx,DWORD[rsp]
and esi,ebp
xor ebp,eax
ror edx,7
punpcklqdq xmm8,xmm7
mov edi,ecx
xor esi,ebp
pxor xmm0,xmm1
rol ecx,5
add ebx,esi
movdqa xmm10,xmm9
xor edi,edx
paddd xmm9,xmm7
xor edx,ebp
pxor xmm0,xmm8
add ebx,ecx
add eax,DWORD[4+rsp]
and edi,edx
xor edx,ebp
ror ecx,7
movdqa xmm8,xmm0
mov esi,ebx
xor edi,edx
movdqa XMMWORD[48+rsp],xmm9
rol ebx,5
add eax,edi
xor esi,ecx
pslld xmm0,2
xor ecx,edx
add eax,ebx
psrld xmm8,30
add ebp,DWORD[8+rsp]
and esi,ecx
xor ecx,edx
por xmm0,xmm8
ror ebx,7
mov edi,eax
xor esi,ecx
rol eax,5
pshufd xmm9,xmm7,238
add ebp,esi
xor edi,ebx
xor ebx,ecx
add ebp,eax
add edx,DWORD[12+rsp]
and edi,ebx
xor ebx,ecx
ror eax,7
mov esi,ebp
xor edi,ebx
rol ebp,5
add edx,edi
xor esi,eax
xor eax,ebx
add edx,ebp
pxor xmm1,xmm5
add ecx,DWORD[16+rsp]
and esi,eax
xor eax,ebx
ror ebp,7
punpcklqdq xmm9,xmm0
mov edi,edx
xor esi,eax
pxor xmm1,xmm2
rol edx,5
add ecx,esi
movdqa xmm8,xmm10
xor edi,ebp
paddd xmm10,xmm0
xor ebp,eax
pxor xmm1,xmm9
add ecx,edx
add ebx,DWORD[20+rsp]
and edi,ebp
xor ebp,eax
ror edx,7
movdqa xmm9,xmm1
mov esi,ecx
xor edi,ebp
movdqa XMMWORD[rsp],xmm10
rol ecx,5
add ebx,edi
xor esi,edx
pslld xmm1,2
xor edx,ebp
add ebx,ecx
psrld xmm9,30
add eax,DWORD[24+rsp]
and esi,edx
xor edx,ebp
por xmm1,xmm9
ror ecx,7
mov edi,ebx
xor esi,edx
rol ebx,5
pshufd xmm10,xmm0,238
add eax,esi
xor edi,ecx
xor ecx,edx
add eax,ebx
add ebp,DWORD[28+rsp]
and edi,ecx
xor ecx,edx
ror ebx,7
mov esi,eax
xor edi,ecx
rol eax,5
add ebp,edi
xor esi,ebx
xor ebx,ecx
add ebp,eax
pxor xmm2,xmm6
add edx,DWORD[32+rsp]
and esi,ebx
xor ebx,ecx
ror eax,7
punpcklqdq xmm10,xmm1
mov edi,ebp
xor esi,ebx
pxor xmm2,xmm3
rol ebp,5
add edx,esi
movdqa xmm9,xmm8
xor edi,eax
paddd xmm8,xmm1
xor eax,ebx
pxor xmm2,xmm10
add edx,ebp
add ecx,DWORD[36+rsp]
and edi,eax
xor eax,ebx
ror ebp,7
movdqa xmm10,xmm2
mov esi,edx
xor edi,eax
movdqa XMMWORD[16+rsp],xmm8
rol edx,5
add ecx,edi
xor esi,ebp
pslld xmm2,2
xor ebp,eax
add ecx,edx
psrld xmm10,30
add ebx,DWORD[40+rsp]
and esi,ebp
xor ebp,eax
por xmm2,xmm10
ror edx,7
mov edi,ecx
xor esi,ebp
rol ecx,5
pshufd xmm8,xmm1,238
add ebx,esi
xor edi,edx
xor edx,ebp
add ebx,ecx
add eax,DWORD[44+rsp]
and edi,edx
xor edx,ebp
ror ecx,7
mov esi,ebx
xor edi,edx
rol ebx,5
add eax,edi
xor esi,edx
add eax,ebx
pxor xmm3,xmm7
add ebp,DWORD[48+rsp]
xor esi,ecx
punpcklqdq xmm8,xmm2
mov edi,eax
rol eax,5
pxor xmm3,xmm4
add ebp,esi
xor edi,ecx
movdqa xmm10,xmm9
ror ebx,7
paddd xmm9,xmm2
add ebp,eax
pxor xmm3,xmm8
add edx,DWORD[52+rsp]
xor edi,ebx
mov esi,ebp
rol ebp,5
movdqa xmm8,xmm3
add edx,edi
xor esi,ebx
movdqa XMMWORD[32+rsp],xmm9
ror eax,7
add edx,ebp
add ecx,DWORD[56+rsp]
pslld xmm3,2
xor esi,eax
mov edi,edx
psrld xmm8,30
rol edx,5
add ecx,esi
xor edi,eax
ror ebp,7
por xmm3,xmm8
add ecx,edx
add ebx,DWORD[60+rsp]
xor edi,ebp
mov esi,ecx
rol ecx,5
add ebx,edi
xor esi,ebp
ror edx,7
add ebx,ecx
add eax,DWORD[rsp]
xor esi,edx
mov edi,ebx
rol ebx,5
paddd xmm10,xmm3
add eax,esi
xor edi,edx
movdqa XMMWORD[48+rsp],xmm10
ror ecx,7
add eax,ebx
add ebp,DWORD[4+rsp]
xor edi,ecx
mov esi,eax
rol eax,5
add ebp,edi
xor esi,ecx
ror ebx,7
add ebp,eax
add edx,DWORD[8+rsp]
xor esi,ebx
mov edi,ebp
rol ebp,5
add edx,esi
xor edi,ebx
ror eax,7
add edx,ebp
add ecx,DWORD[12+rsp]
xor edi,eax
mov esi,edx
rol edx,5
add ecx,edi
xor esi,eax
ror ebp,7
add ecx,edx
cmp r9,r10
je NEAR $L$done_ssse3
movdqa xmm6,XMMWORD[64+r14]
movdqa xmm9,XMMWORD[((-64))+r14]
movdqu xmm0,XMMWORD[r9]
movdqu xmm1,XMMWORD[16+r9]
movdqu xmm2,XMMWORD[32+r9]
movdqu xmm3,XMMWORD[48+r9]
DB 102,15,56,0,198
add r9,64
add ebx,DWORD[16+rsp]
xor esi,ebp
mov edi,ecx
DB 102,15,56,0,206
rol ecx,5
add ebx,esi
xor edi,ebp
ror edx,7
paddd xmm0,xmm9
add ebx,ecx
add eax,DWORD[20+rsp]
xor edi,edx
mov esi,ebx
movdqa XMMWORD[rsp],xmm0
rol ebx,5
add eax,edi
xor esi,edx
ror ecx,7
psubd xmm0,xmm9
add eax,ebx
add ebp,DWORD[24+rsp]
xor esi,ecx
mov edi,eax
rol eax,5
add ebp,esi
xor edi,ecx
ror ebx,7
add ebp,eax
add edx,DWORD[28+rsp]
xor edi,ebx
mov esi,ebp
rol ebp,5
add edx,edi
xor esi,ebx
ror eax,7
add edx,ebp
add ecx,DWORD[32+rsp]
xor esi,eax
mov edi,edx
DB 102,15,56,0,214
rol edx,5
add ecx,esi
xor edi,eax
ror ebp,7
paddd xmm1,xmm9
add ecx,edx
add ebx,DWORD[36+rsp]
xor edi,ebp
mov esi,ecx
movdqa XMMWORD[16+rsp],xmm1
rol ecx,5
add ebx,edi
xor esi,ebp
ror edx,7
psubd xmm1,xmm9
add ebx,ecx
add eax,DWORD[40+rsp]
xor esi,edx
mov edi,ebx
rol ebx,5
add eax,esi
xor edi,edx
ror ecx,7
add eax,ebx
add ebp,DWORD[44+rsp]
xor edi,ecx
mov esi,eax
rol eax,5
add ebp,edi
xor esi,ecx
ror ebx,7
add ebp,eax
add edx,DWORD[48+rsp]
xor esi,ebx
mov edi,ebp
DB 102,15,56,0,222
rol ebp,5
add edx,esi
xor edi,ebx
ror eax,7
paddd xmm2,xmm9
add edx,ebp
add ecx,DWORD[52+rsp]
xor edi,eax
mov esi,edx
movdqa XMMWORD[32+rsp],xmm2
rol edx,5
add ecx,edi
xor esi,eax
ror ebp,7
psubd xmm2,xmm9
add ecx,edx
add ebx,DWORD[56+rsp]
xor esi,ebp
mov edi,ecx
rol ecx,5
add ebx,esi
xor edi,ebp
ror edx,7
add ebx,ecx
add eax,DWORD[60+rsp]
xor edi,edx
mov esi,ebx
rol ebx,5
add eax,edi
ror ecx,7
add eax,ebx
add eax,DWORD[r8]
add esi,DWORD[4+r8]
add ecx,DWORD[8+r8]
add edx,DWORD[12+r8]
mov DWORD[r8],eax
add ebp,DWORD[16+r8]
mov DWORD[4+r8],esi
mov ebx,esi
mov DWORD[8+r8],ecx
mov edi,ecx
mov DWORD[12+r8],edx
xor edi,edx
mov DWORD[16+r8],ebp
and esi,edi
jmp NEAR $L$oop_ssse3
ALIGN 16
$L$done_ssse3:
add ebx,DWORD[16+rsp]
xor esi,ebp
mov edi,ecx
rol ecx,5
add ebx,esi
xor edi,ebp
ror edx,7
add ebx,ecx
add eax,DWORD[20+rsp]
xor edi,edx
mov esi,ebx
rol ebx,5
add eax,edi
xor esi,edx
ror ecx,7
add eax,ebx
add ebp,DWORD[24+rsp]
xor esi,ecx
mov edi,eax
rol eax,5
add ebp,esi
xor edi,ecx
ror ebx,7
add ebp,eax
add edx,DWORD[28+rsp]
xor edi,ebx
mov esi,ebp
rol ebp,5
add edx,edi
xor esi,ebx
ror eax,7
add edx,ebp
add ecx,DWORD[32+rsp]
xor esi,eax
mov edi,edx
rol edx,5
add ecx,esi
xor edi,eax
ror ebp,7
add ecx,edx
add ebx,DWORD[36+rsp]
xor edi,ebp
mov esi,ecx
rol ecx,5
add ebx,edi
xor esi,ebp
ror edx,7
add ebx,ecx
add eax,DWORD[40+rsp]
xor esi,edx
mov edi,ebx
rol ebx,5
add eax,esi
xor edi,edx
ror ecx,7
add eax,ebx
add ebp,DWORD[44+rsp]
xor edi,ecx
mov esi,eax
rol eax,5
add ebp,edi
xor esi,ecx
ror ebx,7
add ebp,eax
add edx,DWORD[48+rsp]
xor esi,ebx
mov edi,ebp
rol ebp,5
add edx,esi
xor edi,ebx
ror eax,7
add edx,ebp
add ecx,DWORD[52+rsp]
xor edi,eax
mov esi,edx
rol edx,5
add ecx,edi
xor esi,eax
ror ebp,7
add ecx,edx
add ebx,DWORD[56+rsp]
xor esi,ebp
mov edi,ecx
rol ecx,5
add ebx,esi
xor edi,ebp
ror edx,7
add ebx,ecx
add eax,DWORD[60+rsp]
xor edi,edx
mov esi,ebx
rol ebx,5
add eax,edi
ror ecx,7
add eax,ebx
add eax,DWORD[r8]
add esi,DWORD[4+r8]
add ecx,DWORD[8+r8]
mov DWORD[r8],eax
add edx,DWORD[12+r8]
mov DWORD[4+r8],esi
add ebp,DWORD[16+r8]
mov DWORD[8+r8],ecx
mov DWORD[12+r8],edx
mov DWORD[16+r8],ebp
movaps xmm6,XMMWORD[((-40-96))+r11]
movaps xmm7,XMMWORD[((-40-80))+r11]
movaps xmm8,XMMWORD[((-40-64))+r11]
movaps xmm9,XMMWORD[((-40-48))+r11]
movaps xmm10,XMMWORD[((-40-32))+r11]
movaps xmm11,XMMWORD[((-40-16))+r11]
mov r14,QWORD[((-40))+r11]
mov r13,QWORD[((-32))+r11]
mov r12,QWORD[((-24))+r11]
mov rbp,QWORD[((-16))+r11]
mov rbx,QWORD[((-8))+r11]
lea rsp,[r11]
$L$epilogue_ssse3:
mov rdi,QWORD[8+rsp] ;WIN64 epilogue
mov rsi,QWORD[16+rsp]
ret
$L$SEH_end_sha1_block_data_order_ssse3:
global sha1_block_data_order_avx
ALIGN 16
sha1_block_data_order_avx:
mov QWORD[8+rsp],rdi ;WIN64 prologue
mov QWORD[16+rsp],rsi
mov rax,rsp
$L$SEH_begin_sha1_block_data_order_avx:
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
_CET_ENDBR
mov r11,rsp
push rbx
push rbp
push r12
push r13
push r14
lea rsp,[((-160))+rsp]
vzeroupper
vmovaps XMMWORD[(-40-96)+r11],xmm6
vmovaps XMMWORD[(-40-80)+r11],xmm7
vmovaps XMMWORD[(-40-64)+r11],xmm8
vmovaps XMMWORD[(-40-48)+r11],xmm9
vmovaps XMMWORD[(-40-32)+r11],xmm10
vmovaps XMMWORD[(-40-16)+r11],xmm11
$L$prologue_avx:
and rsp,-64
mov r8,rdi
mov r9,rsi
mov r10,rdx
shl r10,6
add r10,r9
lea r14,[((K_XX_XX+64))]
mov eax,DWORD[r8]
mov ebx,DWORD[4+r8]
mov ecx,DWORD[8+r8]
mov edx,DWORD[12+r8]
mov esi,ebx
mov ebp,DWORD[16+r8]
mov edi,ecx
xor edi,edx
and esi,edi
vmovdqa xmm6,XMMWORD[64+r14]
vmovdqa xmm11,XMMWORD[((-64))+r14]
vmovdqu xmm0,XMMWORD[r9]
vmovdqu xmm1,XMMWORD[16+r9]
vmovdqu xmm2,XMMWORD[32+r9]
vmovdqu xmm3,XMMWORD[48+r9]
vpshufb xmm0,xmm0,xmm6
add r9,64
vpshufb xmm1,xmm1,xmm6
vpshufb xmm2,xmm2,xmm6
vpshufb xmm3,xmm3,xmm6
vpaddd xmm4,xmm0,xmm11
vpaddd xmm5,xmm1,xmm11
vpaddd xmm6,xmm2,xmm11
vmovdqa XMMWORD[rsp],xmm4
vmovdqa XMMWORD[16+rsp],xmm5
vmovdqa XMMWORD[32+rsp],xmm6
jmp NEAR $L$oop_avx
ALIGN 16
$L$oop_avx:
shrd ebx,ebx,2
xor esi,edx
vpalignr xmm4,xmm1,xmm0,8
mov edi,eax
add ebp,DWORD[rsp]
vpaddd xmm9,xmm11,xmm3
xor ebx,ecx
shld eax,eax,5
vpsrldq xmm8,xmm3,4
add ebp,esi
and edi,ebx
vpxor xmm4,xmm4,xmm0
xor ebx,ecx
add ebp,eax
vpxor xmm8,xmm8,xmm2
shrd eax,eax,7
xor edi,ecx
mov esi,ebp
add edx,DWORD[4+rsp]
vpxor xmm4,xmm4,xmm8
xor eax,ebx
shld ebp,ebp,5
vmovdqa XMMWORD[48+rsp],xmm9
add edx,edi
and esi,eax
vpsrld xmm8,xmm4,31
xor eax,ebx
add edx,ebp
shrd ebp,ebp,7
xor esi,ebx
vpslldq xmm10,xmm4,12
vpaddd xmm4,xmm4,xmm4
mov edi,edx
add ecx,DWORD[8+rsp]
xor ebp,eax
shld edx,edx,5
vpsrld xmm9,xmm10,30
vpor xmm4,xmm4,xmm8
add ecx,esi
and edi,ebp
xor ebp,eax
add ecx,edx
vpslld xmm10,xmm10,2
vpxor xmm4,xmm4,xmm9
shrd edx,edx,7
xor edi,eax
mov esi,ecx
add ebx,DWORD[12+rsp]
vpxor xmm4,xmm4,xmm10
xor edx,ebp
shld ecx,ecx,5
add ebx,edi
and esi,edx
xor edx,ebp
add ebx,ecx
shrd ecx,ecx,7
xor esi,ebp
vpalignr xmm5,xmm2,xmm1,8
mov edi,ebx
add eax,DWORD[16+rsp]
vpaddd xmm9,xmm11,xmm4
xor ecx,edx
shld ebx,ebx,5
vpsrldq xmm8,xmm4,4
add eax,esi
and edi,ecx
vpxor xmm5,xmm5,xmm1
xor ecx,edx
add eax,ebx
vpxor xmm8,xmm8,xmm3
shrd ebx,ebx,7
xor edi,edx
mov esi,eax
add ebp,DWORD[20+rsp]
vpxor xmm5,xmm5,xmm8
xor ebx,ecx
shld eax,eax,5
vmovdqa XMMWORD[rsp],xmm9
add ebp,edi
and esi,ebx
vpsrld xmm8,xmm5,31
xor ebx,ecx
add ebp,eax
shrd eax,eax,7
xor esi,ecx
vpslldq xmm10,xmm5,12
vpaddd xmm5,xmm5,xmm5
mov edi,ebp
add edx,DWORD[24+rsp]
xor eax,ebx
shld ebp,ebp,5
vpsrld xmm9,xmm10,30
vpor xmm5,xmm5,xmm8
add edx,esi
and edi,eax
xor eax,ebx
add edx,ebp
vpslld xmm10,xmm10,2
vpxor xmm5,xmm5,xmm9
shrd ebp,ebp,7
xor edi,ebx
mov esi,edx
add ecx,DWORD[28+rsp]
vpxor xmm5,xmm5,xmm10
xor ebp,eax
shld edx,edx,5
vmovdqa xmm11,XMMWORD[((-32))+r14]
add ecx,edi
and esi,ebp
xor ebp,eax
add ecx,edx
shrd edx,edx,7
xor esi,eax
vpalignr xmm6,xmm3,xmm2,8
mov edi,ecx
add ebx,DWORD[32+rsp]
vpaddd xmm9,xmm11,xmm5
xor edx,ebp
shld ecx,ecx,5
vpsrldq xmm8,xmm5,4
add ebx,esi
and edi,edx
vpxor xmm6,xmm6,xmm2
xor edx,ebp
add ebx,ecx
vpxor xmm8,xmm8,xmm4
shrd ecx,ecx,7
xor edi,ebp
mov esi,ebx
add eax,DWORD[36+rsp]
vpxor xmm6,xmm6,xmm8
xor ecx,edx
shld ebx,ebx,5
vmovdqa XMMWORD[16+rsp],xmm9
add eax,edi
and esi,ecx
vpsrld xmm8,xmm6,31
xor ecx,edx
add eax,ebx
shrd ebx,ebx,7
xor esi,edx
vpslldq xmm10,xmm6,12
vpaddd xmm6,xmm6,xmm6
mov edi,eax
add ebp,DWORD[40+rsp]
xor ebx,ecx
shld eax,eax,5
vpsrld xmm9,xmm10,30
vpor xmm6,xmm6,xmm8
add ebp,esi
and edi,ebx
xor ebx,ecx
add ebp,eax
vpslld xmm10,xmm10,2
vpxor xmm6,xmm6,xmm9
shrd eax,eax,7
xor edi,ecx
mov esi,ebp
add edx,DWORD[44+rsp]
vpxor xmm6,xmm6,xmm10
xor eax,ebx
shld ebp,ebp,5
add edx,edi
and esi,eax
xor eax,ebx
add edx,ebp
shrd ebp,ebp,7
xor esi,ebx
vpalignr xmm7,xmm4,xmm3,8
mov edi,edx
add ecx,DWORD[48+rsp]
vpaddd xmm9,xmm11,xmm6
xor ebp,eax
shld edx,edx,5
vpsrldq xmm8,xmm6,4
add ecx,esi
and edi,ebp
vpxor xmm7,xmm7,xmm3
xor ebp,eax
add ecx,edx
vpxor xmm8,xmm8,xmm5
shrd edx,edx,7
xor edi,eax
mov esi,ecx
add ebx,DWORD[52+rsp]
vpxor xmm7,xmm7,xmm8
xor edx,ebp
shld ecx,ecx,5
vmovdqa XMMWORD[32+rsp],xmm9
add ebx,edi
and esi,edx
vpsrld xmm8,xmm7,31
xor edx,ebp
add ebx,ecx
shrd ecx,ecx,7
xor esi,ebp
vpslldq xmm10,xmm7,12
vpaddd xmm7,xmm7,xmm7
mov edi,ebx
add eax,DWORD[56+rsp]
xor ecx,edx
shld ebx,ebx,5
vpsrld xmm9,xmm10,30
vpor xmm7,xmm7,xmm8
add eax,esi
and edi,ecx
xor ecx,edx
add eax,ebx
vpslld xmm10,xmm10,2
vpxor xmm7,xmm7,xmm9
shrd ebx,ebx,7
xor edi,edx
mov esi,eax
add ebp,DWORD[60+rsp]
vpxor xmm7,xmm7,xmm10
xor ebx,ecx
shld eax,eax,5
add ebp,edi
and esi,ebx
xor ebx,ecx
add ebp,eax
vpalignr xmm8,xmm7,xmm6,8
vpxor xmm0,xmm0,xmm4
shrd eax,eax,7
xor esi,ecx
mov edi,ebp
add edx,DWORD[rsp]
vpxor xmm0,xmm0,xmm1
xor eax,ebx
shld ebp,ebp,5
vpaddd xmm9,xmm11,xmm7
add edx,esi
and edi,eax
vpxor xmm0,xmm0,xmm8
xor eax,ebx
add edx,ebp
shrd ebp,ebp,7
xor edi,ebx
vpsrld xmm8,xmm0,30
vmovdqa XMMWORD[48+rsp],xmm9
mov esi,edx
add ecx,DWORD[4+rsp]
xor ebp,eax
shld edx,edx,5
vpslld xmm0,xmm0,2
add ecx,edi
and esi,ebp
xor ebp,eax
add ecx,edx
shrd edx,edx,7
xor esi,eax
mov edi,ecx
add ebx,DWORD[8+rsp]
vpor xmm0,xmm0,xmm8
xor edx,ebp
shld ecx,ecx,5
add ebx,esi
and edi,edx
xor edx,ebp
add ebx,ecx
add eax,DWORD[12+rsp]
xor edi,ebp
mov esi,ebx
shld ebx,ebx,5
add eax,edi
xor esi,edx
shrd ecx,ecx,7
add eax,ebx
vpalignr xmm8,xmm0,xmm7,8
vpxor xmm1,xmm1,xmm5
add ebp,DWORD[16+rsp]
xor esi,ecx
mov edi,eax
shld eax,eax,5
vpxor xmm1,xmm1,xmm2
add ebp,esi
xor edi,ecx
vpaddd xmm9,xmm11,xmm0
shrd ebx,ebx,7
add ebp,eax
vpxor xmm1,xmm1,xmm8
add edx,DWORD[20+rsp]
xor edi,ebx
mov esi,ebp
shld ebp,ebp,5
vpsrld xmm8,xmm1,30
vmovdqa XMMWORD[rsp],xmm9
add edx,edi
xor esi,ebx
shrd eax,eax,7
add edx,ebp
vpslld xmm1,xmm1,2
add ecx,DWORD[24+rsp]
xor esi,eax
mov edi,edx
shld edx,edx,5
add ecx,esi
xor edi,eax
shrd ebp,ebp,7
add ecx,edx
vpor xmm1,xmm1,xmm8
add ebx,DWORD[28+rsp]
xor edi,ebp
mov esi,ecx
shld ecx,ecx,5
add ebx,edi
xor esi,ebp
shrd edx,edx,7
add ebx,ecx
vpalignr xmm8,xmm1,xmm0,8
vpxor xmm2,xmm2,xmm6
add eax,DWORD[32+rsp]
xor esi,edx
mov edi,ebx
shld ebx,ebx,5
vpxor xmm2,xmm2,xmm3
add eax,esi
xor edi,edx
vpaddd xmm9,xmm11,xmm1
vmovdqa xmm11,XMMWORD[r14]
shrd ecx,ecx,7
add eax,ebx
vpxor xmm2,xmm2,xmm8
add ebp,DWORD[36+rsp]
xor edi,ecx
mov esi,eax
shld eax,eax,5
vpsrld xmm8,xmm2,30
vmovdqa XMMWORD[16+rsp],xmm9
add ebp,edi
xor esi,ecx
shrd ebx,ebx,7
add ebp,eax
vpslld xmm2,xmm2,2
add edx,DWORD[40+rsp]
xor esi,ebx
mov edi,ebp
shld ebp,ebp,5
add edx,esi
xor edi,ebx
shrd eax,eax,7
add edx,ebp
vpor xmm2,xmm2,xmm8
add ecx,DWORD[44+rsp]
xor edi,eax
mov esi,edx
shld edx,edx,5
add ecx,edi
xor esi,eax
shrd ebp,ebp,7
add ecx,edx
vpalignr xmm8,xmm2,xmm1,8
vpxor xmm3,xmm3,xmm7
add ebx,DWORD[48+rsp]
xor esi,ebp
mov edi,ecx
shld ecx,ecx,5
vpxor xmm3,xmm3,xmm4
add ebx,esi
xor edi,ebp
vpaddd xmm9,xmm11,xmm2
shrd edx,edx,7
add ebx,ecx
vpxor xmm3,xmm3,xmm8
add eax,DWORD[52+rsp]
xor edi,edx
mov esi,ebx
shld ebx,ebx,5
vpsrld xmm8,xmm3,30
vmovdqa XMMWORD[32+rsp],xmm9
add eax,edi
xor esi,edx
shrd ecx,ecx,7
add eax,ebx
vpslld xmm3,xmm3,2
add ebp,DWORD[56+rsp]
xor esi,ecx
mov edi,eax
shld eax,eax,5
add ebp,esi
xor edi,ecx
shrd ebx,ebx,7
add ebp,eax
vpor xmm3,xmm3,xmm8
add edx,DWORD[60+rsp]
xor edi,ebx
mov esi,ebp
shld ebp,ebp,5
add edx,edi
xor esi,ebx
shrd eax,eax,7
add edx,ebp
vpalignr xmm8,xmm3,xmm2,8
vpxor xmm4,xmm4,xmm0
add ecx,DWORD[rsp]
xor esi,eax
mov edi,edx
shld edx,edx,5
vpxor xmm4,xmm4,xmm5
add ecx,esi
xor edi,eax
vpaddd xmm9,xmm11,xmm3
shrd ebp,ebp,7
add ecx,edx
vpxor xmm4,xmm4,xmm8
add ebx,DWORD[4+rsp]
xor edi,ebp
mov esi,ecx
shld ecx,ecx,5
vpsrld xmm8,xmm4,30
vmovdqa XMMWORD[48+rsp],xmm9
add ebx,edi
xor esi,ebp
shrd edx,edx,7
add ebx,ecx
vpslld xmm4,xmm4,2
add eax,DWORD[8+rsp]
xor esi,edx
mov edi,ebx
shld ebx,ebx,5
add eax,esi
xor edi,edx
shrd ecx,ecx,7
add eax,ebx
vpor xmm4,xmm4,xmm8
add ebp,DWORD[12+rsp]
xor edi,ecx
mov esi,eax
shld eax,eax,5
add ebp,edi
xor esi,ecx
shrd ebx,ebx,7
add ebp,eax
vpalignr xmm8,xmm4,xmm3,8
vpxor xmm5,xmm5,xmm1
add edx,DWORD[16+rsp]
xor esi,ebx
mov edi,ebp
shld ebp,ebp,5
vpxor xmm5,xmm5,xmm6
add edx,esi
xor edi,ebx
vpaddd xmm9,xmm11,xmm4
shrd eax,eax,7
add edx,ebp
vpxor xmm5,xmm5,xmm8
add ecx,DWORD[20+rsp]
xor edi,eax
mov esi,edx
shld edx,edx,5
vpsrld xmm8,xmm5,30
vmovdqa XMMWORD[rsp],xmm9
add ecx,edi
xor esi,eax
shrd ebp,ebp,7
add ecx,edx
vpslld xmm5,xmm5,2
add ebx,DWORD[24+rsp]
xor esi,ebp
mov edi,ecx
shld ecx,ecx,5
add ebx,esi
xor edi,ebp
shrd edx,edx,7
add ebx,ecx
vpor xmm5,xmm5,xmm8
add eax,DWORD[28+rsp]
shrd ecx,ecx,7
mov esi,ebx
xor edi,edx
shld ebx,ebx,5
add eax,edi
xor esi,ecx
xor ecx,edx
add eax,ebx
vpalignr xmm8,xmm5,xmm4,8
vpxor xmm6,xmm6,xmm2
add ebp,DWORD[32+rsp]
and esi,ecx
xor ecx,edx
shrd ebx,ebx,7
vpxor xmm6,xmm6,xmm7
mov edi,eax
xor esi,ecx
vpaddd xmm9,xmm11,xmm5
shld eax,eax,5
add ebp,esi
vpxor xmm6,xmm6,xmm8
xor edi,ebx
xor ebx,ecx
add ebp,eax
add edx,DWORD[36+rsp]
vpsrld xmm8,xmm6,30
vmovdqa XMMWORD[16+rsp],xmm9
and edi,ebx
xor ebx,ecx
shrd eax,eax,7
mov esi,ebp
vpslld xmm6,xmm6,2
xor edi,ebx
shld ebp,ebp,5
add edx,edi
xor esi,eax
xor eax,ebx
add edx,ebp
add ecx,DWORD[40+rsp]
and esi,eax
vpor xmm6,xmm6,xmm8
xor eax,ebx
shrd ebp,ebp,7
mov edi,edx
xor esi,eax
shld edx,edx,5
add ecx,esi
xor edi,ebp
xor ebp,eax
add ecx,edx
add ebx,DWORD[44+rsp]
and edi,ebp
xor ebp,eax
shrd edx,edx,7
mov esi,ecx
xor edi,ebp
shld ecx,ecx,5
add ebx,edi
xor esi,edx
xor edx,ebp
add ebx,ecx
vpalignr xmm8,xmm6,xmm5,8
vpxor xmm7,xmm7,xmm3
add eax,DWORD[48+rsp]
and esi,edx
xor edx,ebp
shrd ecx,ecx,7
vpxor xmm7,xmm7,xmm0
mov edi,ebx
xor esi,edx
vpaddd xmm9,xmm11,xmm6
vmovdqa xmm11,XMMWORD[32+r14]
shld ebx,ebx,5
add eax,esi
vpxor xmm7,xmm7,xmm8
xor edi,ecx
xor ecx,edx
add eax,ebx
add ebp,DWORD[52+rsp]
vpsrld xmm8,xmm7,30
vmovdqa XMMWORD[32+rsp],xmm9
and edi,ecx
xor ecx,edx
shrd ebx,ebx,7
mov esi,eax
vpslld xmm7,xmm7,2
xor edi,ecx
shld eax,eax,5
add ebp,edi
xor esi,ebx
xor ebx,ecx
add ebp,eax
add edx,DWORD[56+rsp]
and esi,ebx
vpor xmm7,xmm7,xmm8
xor ebx,ecx
shrd eax,eax,7
mov edi,ebp
xor esi,ebx
shld ebp,ebp,5
add edx,esi
xor edi,eax
xor eax,ebx
add edx,ebp
add ecx,DWORD[60+rsp]
and edi,eax
xor eax,ebx
shrd ebp,ebp,7
mov esi,edx
xor edi,eax
shld edx,edx,5
add ecx,edi
xor esi,ebp
xor ebp,eax
add ecx,edx
vpalignr xmm8,xmm7,xmm6,8
vpxor xmm0,xmm0,xmm4
add ebx,DWORD[rsp]
and esi,ebp
xor ebp,eax
shrd edx,edx,7
vpxor xmm0,xmm0,xmm1
mov edi,ecx
xor esi,ebp
vpaddd xmm9,xmm11,xmm7
shld ecx,ecx,5
add ebx,esi
vpxor xmm0,xmm0,xmm8
xor edi,edx
xor edx,ebp
add ebx,ecx
add eax,DWORD[4+rsp]
vpsrld xmm8,xmm0,30
vmovdqa XMMWORD[48+rsp],xmm9
and edi,edx
xor edx,ebp
shrd ecx,ecx,7
mov esi,ebx
vpslld xmm0,xmm0,2
xor edi,edx
shld ebx,ebx,5
add eax,edi
xor esi,ecx
xor ecx,edx
add eax,ebx
add ebp,DWORD[8+rsp]
and esi,ecx
vpor xmm0,xmm0,xmm8
xor ecx,edx
shrd ebx,ebx,7
mov edi,eax
xor esi,ecx
shld eax,eax,5
add ebp,esi
xor edi,ebx
xor ebx,ecx
add ebp,eax
add edx,DWORD[12+rsp]
and edi,ebx
xor ebx,ecx
shrd eax,eax,7
mov esi,ebp
xor edi,ebx
shld ebp,ebp,5
add edx,edi
xor esi,eax
xor eax,ebx
add edx,ebp
vpalignr xmm8,xmm0,xmm7,8
vpxor xmm1,xmm1,xmm5
add ecx,DWORD[16+rsp]
and esi,eax
xor eax,ebx
shrd ebp,ebp,7
vpxor xmm1,xmm1,xmm2
mov edi,edx
xor esi,eax
vpaddd xmm9,xmm11,xmm0
shld edx,edx,5
add ecx,esi
vpxor xmm1,xmm1,xmm8
xor edi,ebp
xor ebp,eax
add ecx,edx
add ebx,DWORD[20+rsp]
vpsrld xmm8,xmm1,30
vmovdqa XMMWORD[rsp],xmm9
and edi,ebp
xor ebp,eax
shrd edx,edx,7
mov esi,ecx
vpslld xmm1,xmm1,2
xor edi,ebp
shld ecx,ecx,5
add ebx,edi
xor esi,edx
xor edx,ebp
add ebx,ecx
add eax,DWORD[24+rsp]
and esi,edx
vpor xmm1,xmm1,xmm8
xor edx,ebp
shrd ecx,ecx,7
mov edi,ebx
xor esi,edx
shld ebx,ebx,5
add eax,esi
xor edi,ecx
xor ecx,edx
add eax,ebx
add ebp,DWORD[28+rsp]
and edi,ecx
xor ecx,edx
shrd ebx,ebx,7
mov esi,eax
xor edi,ecx
shld eax,eax,5
add ebp,edi
xor esi,ebx
xor ebx,ecx
add ebp,eax
vpalignr xmm8,xmm1,xmm0,8
vpxor xmm2,xmm2,xmm6
add edx,DWORD[32+rsp]
and esi,ebx
xor ebx,ecx
shrd eax,eax,7
vpxor xmm2,xmm2,xmm3
mov edi,ebp
xor esi,ebx
vpaddd xmm9,xmm11,xmm1
shld ebp,ebp,5
add edx,esi
vpxor xmm2,xmm2,xmm8
xor edi,eax
xor eax,ebx
add edx,ebp
add ecx,DWORD[36+rsp]
vpsrld xmm8,xmm2,30
vmovdqa XMMWORD[16+rsp],xmm9
and edi,eax
xor eax,ebx
shrd ebp,ebp,7
mov esi,edx
vpslld xmm2,xmm2,2
xor edi,eax
shld edx,edx,5
add ecx,edi
xor esi,ebp
xor ebp,eax
add ecx,edx
add ebx,DWORD[40+rsp]
and esi,ebp
vpor xmm2,xmm2,xmm8
xor ebp,eax
shrd edx,edx,7
mov edi,ecx
xor esi,ebp
shld ecx,ecx,5
add ebx,esi
xor edi,edx
xor edx,ebp
add ebx,ecx
add eax,DWORD[44+rsp]
and edi,edx
xor edx,ebp
shrd ecx,ecx,7
mov esi,ebx
xor edi,edx
shld ebx,ebx,5
add eax,edi
xor esi,edx
add eax,ebx
vpalignr xmm8,xmm2,xmm1,8
vpxor xmm3,xmm3,xmm7
add ebp,DWORD[48+rsp]
xor esi,ecx
mov edi,eax
shld eax,eax,5
vpxor xmm3,xmm3,xmm4
add ebp,esi
xor edi,ecx
vpaddd xmm9,xmm11,xmm2
shrd ebx,ebx,7
add ebp,eax
vpxor xmm3,xmm3,xmm8
add edx,DWORD[52+rsp]
xor edi,ebx
mov esi,ebp
shld ebp,ebp,5
vpsrld xmm8,xmm3,30
vmovdqa XMMWORD[32+rsp],xmm9
add edx,edi
xor esi,ebx
shrd eax,eax,7
add edx,ebp
vpslld xmm3,xmm3,2
add ecx,DWORD[56+rsp]
xor esi,eax
mov edi,edx
shld edx,edx,5
add ecx,esi
xor edi,eax
shrd ebp,ebp,7
add ecx,edx
vpor xmm3,xmm3,xmm8
add ebx,DWORD[60+rsp]
xor edi,ebp
mov esi,ecx
shld ecx,ecx,5
add ebx,edi
xor esi,ebp
shrd edx,edx,7
add ebx,ecx
add eax,DWORD[rsp]
vpaddd xmm9,xmm11,xmm3
xor esi,edx
mov edi,ebx
shld ebx,ebx,5
add eax,esi
vmovdqa XMMWORD[48+rsp],xmm9
xor edi,edx
shrd ecx,ecx,7
add eax,ebx
add ebp,DWORD[4+rsp]
xor edi,ecx
mov esi,eax
shld eax,eax,5
add ebp,edi
xor esi,ecx
shrd ebx,ebx,7
add ebp,eax
add edx,DWORD[8+rsp]
xor esi,ebx
mov edi,ebp
shld ebp,ebp,5
add edx,esi
xor edi,ebx
shrd eax,eax,7
add edx,ebp
add ecx,DWORD[12+rsp]
xor edi,eax
mov esi,edx
shld edx,edx,5
add ecx,edi
xor esi,eax
shrd ebp,ebp,7
add ecx,edx
cmp r9,r10
je NEAR $L$done_avx
vmovdqa xmm6,XMMWORD[64+r14]
vmovdqa xmm11,XMMWORD[((-64))+r14]
vmovdqu xmm0,XMMWORD[r9]
vmovdqu xmm1,XMMWORD[16+r9]
vmovdqu xmm2,XMMWORD[32+r9]
vmovdqu xmm3,XMMWORD[48+r9]
vpshufb xmm0,xmm0,xmm6
add r9,64
add ebx,DWORD[16+rsp]
xor esi,ebp
vpshufb xmm1,xmm1,xmm6
mov edi,ecx
shld ecx,ecx,5
vpaddd xmm4,xmm0,xmm11
add ebx,esi
xor edi,ebp
shrd edx,edx,7
add ebx,ecx
vmovdqa XMMWORD[rsp],xmm4
add eax,DWORD[20+rsp]
xor edi,edx
mov esi,ebx
shld ebx,ebx,5
add eax,edi
xor esi,edx
shrd ecx,ecx,7
add eax,ebx
add ebp,DWORD[24+rsp]
xor esi,ecx
mov edi,eax
shld eax,eax,5
add ebp,esi
xor edi,ecx
shrd ebx,ebx,7
add ebp,eax
add edx,DWORD[28+rsp]
xor edi,ebx
mov esi,ebp
shld ebp,ebp,5
add edx,edi
xor esi,ebx
shrd eax,eax,7
add edx,ebp
add ecx,DWORD[32+rsp]
xor esi,eax
vpshufb xmm2,xmm2,xmm6
mov edi,edx
shld edx,edx,5
vpaddd xmm5,xmm1,xmm11
add ecx,esi
xor edi,eax
shrd ebp,ebp,7
add ecx,edx
vmovdqa XMMWORD[16+rsp],xmm5
add ebx,DWORD[36+rsp]
xor edi,ebp
mov esi,ecx
shld ecx,ecx,5
add ebx,edi
xor esi,ebp
shrd edx,edx,7
add ebx,ecx
add eax,DWORD[40+rsp]
xor esi,edx
mov edi,ebx
shld ebx,ebx,5
add eax,esi
xor edi,edx
shrd ecx,ecx,7
add eax,ebx
add ebp,DWORD[44+rsp]
xor edi,ecx
mov esi,eax
shld eax,eax,5
add ebp,edi
xor esi,ecx
shrd ebx,ebx,7
add ebp,eax
add edx,DWORD[48+rsp]
xor esi,ebx
vpshufb xmm3,xmm3,xmm6
mov edi,ebp
shld ebp,ebp,5
vpaddd xmm6,xmm2,xmm11
add edx,esi
xor edi,ebx
shrd eax,eax,7
add edx,ebp
vmovdqa XMMWORD[32+rsp],xmm6
add ecx,DWORD[52+rsp]
xor edi,eax
mov esi,edx
shld edx,edx,5
add ecx,edi
xor esi,eax
shrd ebp,ebp,7
add ecx,edx
add ebx,DWORD[56+rsp]
xor esi,ebp
mov edi,ecx
shld ecx,ecx,5
add ebx,esi
xor edi,ebp
shrd edx,edx,7
add ebx,ecx
add eax,DWORD[60+rsp]
xor edi,edx
mov esi,ebx
shld ebx,ebx,5
add eax,edi
shrd ecx,ecx,7
add eax,ebx
add eax,DWORD[r8]
add esi,DWORD[4+r8]
add ecx,DWORD[8+r8]
add edx,DWORD[12+r8]
mov DWORD[r8],eax
add ebp,DWORD[16+r8]
mov DWORD[4+r8],esi
mov ebx,esi
mov DWORD[8+r8],ecx
mov edi,ecx
mov DWORD[12+r8],edx
xor edi,edx
mov DWORD[16+r8],ebp
and esi,edi
jmp NEAR $L$oop_avx
ALIGN 16
$L$done_avx:
add ebx,DWORD[16+rsp]
xor esi,ebp
mov edi,ecx
shld ecx,ecx,5
add ebx,esi
xor edi,ebp
shrd edx,edx,7
add ebx,ecx
add eax,DWORD[20+rsp]
xor edi,edx
mov esi,ebx
shld ebx,ebx,5
add eax,edi
xor esi,edx
shrd ecx,ecx,7
add eax,ebx
add ebp,DWORD[24+rsp]
xor esi,ecx
mov edi,eax
shld eax,eax,5
add ebp,esi
xor edi,ecx
shrd ebx,ebx,7
add ebp,eax
add edx,DWORD[28+rsp]
xor edi,ebx
mov esi,ebp
shld ebp,ebp,5
add edx,edi
xor esi,ebx
shrd eax,eax,7
add edx,ebp
add ecx,DWORD[32+rsp]
xor esi,eax
mov edi,edx
shld edx,edx,5
add ecx,esi
xor edi,eax
shrd ebp,ebp,7
add ecx,edx
add ebx,DWORD[36+rsp]
xor edi,ebp
mov esi,ecx
shld ecx,ecx,5
add ebx,edi
xor esi,ebp
shrd edx,edx,7
add ebx,ecx
add eax,DWORD[40+rsp]
xor esi,edx
mov edi,ebx
shld ebx,ebx,5
add eax,esi
xor edi,edx
shrd ecx,ecx,7
add eax,ebx
add ebp,DWORD[44+rsp]
xor edi,ecx
mov esi,eax
shld eax,eax,5
add ebp,edi
xor esi,ecx
shrd ebx,ebx,7
add ebp,eax
add edx,DWORD[48+rsp]
xor esi,ebx
mov edi,ebp
shld ebp,ebp,5
add edx,esi
xor edi,ebx
shrd eax,eax,7
add edx,ebp
add ecx,DWORD[52+rsp]
xor edi,eax
mov esi,edx
shld edx,edx,5
add ecx,edi
xor esi,eax
shrd ebp,ebp,7
add ecx,edx
add ebx,DWORD[56+rsp]
xor esi,ebp
mov edi,ecx
shld ecx,ecx,5
add ebx,esi
xor edi,ebp
shrd edx,edx,7
add ebx,ecx
add eax,DWORD[60+rsp]
xor edi,edx
mov esi,ebx
shld ebx,ebx,5
add eax,edi
shrd ecx,ecx,7
add eax,ebx
vzeroupper
add eax,DWORD[r8]
add esi,DWORD[4+r8]
add ecx,DWORD[8+r8]
mov DWORD[r8],eax
add edx,DWORD[12+r8]
mov DWORD[4+r8],esi
add ebp,DWORD[16+r8]
mov DWORD[8+r8],ecx
mov DWORD[12+r8],edx
mov DWORD[16+r8],ebp
movaps xmm6,XMMWORD[((-40-96))+r11]
movaps xmm7,XMMWORD[((-40-80))+r11]
movaps xmm8,XMMWORD[((-40-64))+r11]
movaps xmm9,XMMWORD[((-40-48))+r11]
movaps xmm10,XMMWORD[((-40-32))+r11]
movaps xmm11,XMMWORD[((-40-16))+r11]
mov r14,QWORD[((-40))+r11]
mov r13,QWORD[((-32))+r11]
mov r12,QWORD[((-24))+r11]
mov rbp,QWORD[((-16))+r11]
mov rbx,QWORD[((-8))+r11]
lea rsp,[r11]
$L$epilogue_avx:
mov rdi,QWORD[8+rsp] ;WIN64 epilogue
mov rsi,QWORD[16+rsp]
ret
$L$SEH_end_sha1_block_data_order_avx:
global sha1_block_data_order_avx2
ALIGN 16
sha1_block_data_order_avx2:
mov QWORD[8+rsp],rdi ;WIN64 prologue
mov QWORD[16+rsp],rsi
mov rax,rsp
$L$SEH_begin_sha1_block_data_order_avx2:
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
_CET_ENDBR
mov r11,rsp
push rbx
push rbp
push r12
push r13
push r14
vzeroupper
lea rsp,[((-96))+rsp]
vmovaps XMMWORD[(-40-96)+r11],xmm6
vmovaps XMMWORD[(-40-80)+r11],xmm7
vmovaps XMMWORD[(-40-64)+r11],xmm8
vmovaps XMMWORD[(-40-48)+r11],xmm9
vmovaps XMMWORD[(-40-32)+r11],xmm10
vmovaps XMMWORD[(-40-16)+r11],xmm11
$L$prologue_avx2:
mov r8,rdi
mov r9,rsi
mov r10,rdx
lea rsp,[((-640))+rsp]
shl r10,6
lea r13,[64+r9]
and rsp,-128
add r10,r9
lea r14,[((K_XX_XX+64))]
mov eax,DWORD[r8]
cmp r13,r10
cmovae r13,r9
mov ebp,DWORD[4+r8]
mov ecx,DWORD[8+r8]
mov edx,DWORD[12+r8]
mov esi,DWORD[16+r8]
vmovdqu ymm6,YMMWORD[64+r14]
vmovdqu xmm0,XMMWORD[r9]
vmovdqu xmm1,XMMWORD[16+r9]
vmovdqu xmm2,XMMWORD[32+r9]
vmovdqu xmm3,XMMWORD[48+r9]
lea r9,[64+r9]
vinserti128 ymm0,ymm0,XMMWORD[r13],1
vinserti128 ymm1,ymm1,XMMWORD[16+r13],1
vpshufb ymm0,ymm0,ymm6
vinserti128 ymm2,ymm2,XMMWORD[32+r13],1
vpshufb ymm1,ymm1,ymm6
vinserti128 ymm3,ymm3,XMMWORD[48+r13],1
vpshufb ymm2,ymm2,ymm6
vmovdqu ymm11,YMMWORD[((-64))+r14]
vpshufb ymm3,ymm3,ymm6
vpaddd ymm4,ymm0,ymm11
vpaddd ymm5,ymm1,ymm11
vmovdqu YMMWORD[rsp],ymm4
vpaddd ymm6,ymm2,ymm11
vmovdqu YMMWORD[32+rsp],ymm5
vpaddd ymm7,ymm3,ymm11
vmovdqu YMMWORD[64+rsp],ymm6
vmovdqu YMMWORD[96+rsp],ymm7
vpalignr ymm4,ymm1,ymm0,8
vpsrldq ymm8,ymm3,4
vpxor ymm4,ymm4,ymm0
vpxor ymm8,ymm8,ymm2
vpxor ymm4,ymm4,ymm8
vpsrld ymm8,ymm4,31
vpslldq ymm10,ymm4,12
vpaddd ymm4,ymm4,ymm4
vpsrld ymm9,ymm10,30
vpor ymm4,ymm4,ymm8
vpslld ymm10,ymm10,2
vpxor ymm4,ymm4,ymm9
vpxor ymm4,ymm4,ymm10
vpaddd ymm9,ymm4,ymm11
vmovdqu YMMWORD[128+rsp],ymm9
vpalignr ymm5,ymm2,ymm1,8
vpsrldq ymm8,ymm4,4
vpxor ymm5,ymm5,ymm1
vpxor ymm8,ymm8,ymm3
vpxor ymm5,ymm5,ymm8
vpsrld ymm8,ymm5,31
vmovdqu ymm11,YMMWORD[((-32))+r14]
vpslldq ymm10,ymm5,12
vpaddd ymm5,ymm5,ymm5
vpsrld ymm9,ymm10,30
vpor ymm5,ymm5,ymm8
vpslld ymm10,ymm10,2
vpxor ymm5,ymm5,ymm9
vpxor ymm5,ymm5,ymm10
vpaddd ymm9,ymm5,ymm11
vmovdqu YMMWORD[160+rsp],ymm9
vpalignr ymm6,ymm3,ymm2,8
vpsrldq ymm8,ymm5,4
vpxor ymm6,ymm6,ymm2
vpxor ymm8,ymm8,ymm4
vpxor ymm6,ymm6,ymm8
vpsrld ymm8,ymm6,31
vpslldq ymm10,ymm6,12
vpaddd ymm6,ymm6,ymm6
vpsrld ymm9,ymm10,30
vpor ymm6,ymm6,ymm8
vpslld ymm10,ymm10,2
vpxor ymm6,ymm6,ymm9
vpxor ymm6,ymm6,ymm10
vpaddd ymm9,ymm6,ymm11
vmovdqu YMMWORD[192+rsp],ymm9
vpalignr ymm7,ymm4,ymm3,8
vpsrldq ymm8,ymm6,4
vpxor ymm7,ymm7,ymm3
vpxor ymm8,ymm8,ymm5
vpxor ymm7,ymm7,ymm8
vpsrld ymm8,ymm7,31
vpslldq ymm10,ymm7,12
vpaddd ymm7,ymm7,ymm7
vpsrld ymm9,ymm10,30
vpor ymm7,ymm7,ymm8
vpslld ymm10,ymm10,2
vpxor ymm7,ymm7,ymm9
vpxor ymm7,ymm7,ymm10
vpaddd ymm9,ymm7,ymm11
vmovdqu YMMWORD[224+rsp],ymm9
lea r13,[128+rsp]
jmp NEAR $L$oop_avx2
ALIGN 32
$L$oop_avx2:
rorx ebx,ebp,2
andn edi,ebp,edx
and ebp,ecx
xor ebp,edi
jmp NEAR $L$align32_1
ALIGN 32
$L$align32_1:
vpalignr ymm8,ymm7,ymm6,8
vpxor ymm0,ymm0,ymm4
add esi,DWORD[((-128))+r13]
andn edi,eax,ecx
vpxor ymm0,ymm0,ymm1
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
vpxor ymm0,ymm0,ymm8
and eax,ebx
add esi,r12d
xor eax,edi
vpsrld ymm8,ymm0,30
vpslld ymm0,ymm0,2
add edx,DWORD[((-124))+r13]
andn edi,esi,ebx
add edx,eax
rorx r12d,esi,27
rorx eax,esi,2
and esi,ebp
vpor ymm0,ymm0,ymm8
add edx,r12d
xor esi,edi
add ecx,DWORD[((-120))+r13]
andn edi,edx,ebp
vpaddd ymm9,ymm0,ymm11
add ecx,esi
rorx r12d,edx,27
rorx esi,edx,2
and edx,eax
vmovdqu YMMWORD[256+rsp],ymm9
add ecx,r12d
xor edx,edi
add ebx,DWORD[((-116))+r13]
andn edi,ecx,eax
add ebx,edx
rorx r12d,ecx,27
rorx edx,ecx,2
and ecx,esi
add ebx,r12d
xor ecx,edi
add ebp,DWORD[((-96))+r13]
andn edi,ebx,esi
add ebp,ecx
rorx r12d,ebx,27
rorx ecx,ebx,2
and ebx,edx
add ebp,r12d
xor ebx,edi
vpalignr ymm8,ymm0,ymm7,8
vpxor ymm1,ymm1,ymm5
add eax,DWORD[((-92))+r13]
andn edi,ebp,edx
vpxor ymm1,ymm1,ymm2
add eax,ebx
rorx r12d,ebp,27
rorx ebx,ebp,2
vpxor ymm1,ymm1,ymm8
and ebp,ecx
add eax,r12d
xor ebp,edi
vpsrld ymm8,ymm1,30
vpslld ymm1,ymm1,2
add esi,DWORD[((-88))+r13]
andn edi,eax,ecx
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
and eax,ebx
vpor ymm1,ymm1,ymm8
add esi,r12d
xor eax,edi
add edx,DWORD[((-84))+r13]
andn edi,esi,ebx
vpaddd ymm9,ymm1,ymm11
add edx,eax
rorx r12d,esi,27
rorx eax,esi,2
and esi,ebp
vmovdqu YMMWORD[288+rsp],ymm9
add edx,r12d
xor esi,edi
add ecx,DWORD[((-64))+r13]
andn edi,edx,ebp
add ecx,esi
rorx r12d,edx,27
rorx esi,edx,2
and edx,eax
add ecx,r12d
xor edx,edi
add ebx,DWORD[((-60))+r13]
andn edi,ecx,eax
add ebx,edx
rorx r12d,ecx,27
rorx edx,ecx,2
and ecx,esi
add ebx,r12d
xor ecx,edi
vpalignr ymm8,ymm1,ymm0,8
vpxor ymm2,ymm2,ymm6
add ebp,DWORD[((-56))+r13]
andn edi,ebx,esi
vpxor ymm2,ymm2,ymm3
vmovdqu ymm11,YMMWORD[r14]
add ebp,ecx
rorx r12d,ebx,27
rorx ecx,ebx,2
vpxor ymm2,ymm2,ymm8
and ebx,edx
add ebp,r12d
xor ebx,edi
vpsrld ymm8,ymm2,30
vpslld ymm2,ymm2,2
add eax,DWORD[((-52))+r13]
andn edi,ebp,edx
add eax,ebx
rorx r12d,ebp,27
rorx ebx,ebp,2
and ebp,ecx
vpor ymm2,ymm2,ymm8
add eax,r12d
xor ebp,edi
add esi,DWORD[((-32))+r13]
andn edi,eax,ecx
vpaddd ymm9,ymm2,ymm11
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
and eax,ebx
vmovdqu YMMWORD[320+rsp],ymm9
add esi,r12d
xor eax,edi
add edx,DWORD[((-28))+r13]
andn edi,esi,ebx
add edx,eax
rorx r12d,esi,27
rorx eax,esi,2
and esi,ebp
add edx,r12d
xor esi,edi
add ecx,DWORD[((-24))+r13]
andn edi,edx,ebp
add ecx,esi
rorx r12d,edx,27
rorx esi,edx,2
and edx,eax
add ecx,r12d
xor edx,edi
vpalignr ymm8,ymm2,ymm1,8
vpxor ymm3,ymm3,ymm7
add ebx,DWORD[((-20))+r13]
andn edi,ecx,eax
vpxor ymm3,ymm3,ymm4
add ebx,edx
rorx r12d,ecx,27
rorx edx,ecx,2
vpxor ymm3,ymm3,ymm8
and ecx,esi
add ebx,r12d
xor ecx,edi
vpsrld ymm8,ymm3,30
vpslld ymm3,ymm3,2
add ebp,DWORD[r13]
andn edi,ebx,esi
add ebp,ecx
rorx r12d,ebx,27
rorx ecx,ebx,2
and ebx,edx
vpor ymm3,ymm3,ymm8
add ebp,r12d
xor ebx,edi
add eax,DWORD[4+r13]
andn edi,ebp,edx
vpaddd ymm9,ymm3,ymm11
add eax,ebx
rorx r12d,ebp,27
rorx ebx,ebp,2
and ebp,ecx
vmovdqu YMMWORD[352+rsp],ymm9
add eax,r12d
xor ebp,edi
add esi,DWORD[8+r13]
andn edi,eax,ecx
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
and eax,ebx
add esi,r12d
xor eax,edi
add edx,DWORD[12+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
vpalignr ymm8,ymm3,ymm2,8
vpxor ymm4,ymm4,ymm0
add ecx,DWORD[32+r13]
lea ecx,[rsi*1+rcx]
vpxor ymm4,ymm4,ymm5
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
vpxor ymm4,ymm4,ymm8
add ecx,r12d
xor edx,ebp
add ebx,DWORD[36+r13]
vpsrld ymm8,ymm4,30
vpslld ymm4,ymm4,2
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
vpor ymm4,ymm4,ymm8
add ebp,DWORD[40+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
vpaddd ymm9,ymm4,ymm11
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[44+r13]
vmovdqu YMMWORD[384+rsp],ymm9
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[64+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
vpalignr ymm8,ymm4,ymm3,8
vpxor ymm5,ymm5,ymm1
add edx,DWORD[68+r13]
lea edx,[rax*1+rdx]
vpxor ymm5,ymm5,ymm6
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
vpxor ymm5,ymm5,ymm8
add edx,r12d
xor esi,ebx
add ecx,DWORD[72+r13]
vpsrld ymm8,ymm5,30
vpslld ymm5,ymm5,2
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
vpor ymm5,ymm5,ymm8
add ebx,DWORD[76+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
vpaddd ymm9,ymm5,ymm11
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[96+r13]
vmovdqu YMMWORD[416+rsp],ymm9
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[100+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
vpalignr ymm8,ymm5,ymm4,8
vpxor ymm6,ymm6,ymm2
add esi,DWORD[104+r13]
lea esi,[rbp*1+rsi]
vpxor ymm6,ymm6,ymm7
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
vpxor ymm6,ymm6,ymm8
add esi,r12d
xor eax,ecx
add edx,DWORD[108+r13]
lea r13,[256+r13]
vpsrld ymm8,ymm6,30
vpslld ymm6,ymm6,2
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
vpor ymm6,ymm6,ymm8
add ecx,DWORD[((-128))+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
vpaddd ymm9,ymm6,ymm11
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[((-124))+r13]
vmovdqu YMMWORD[448+rsp],ymm9
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[((-120))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
vpalignr ymm8,ymm6,ymm5,8
vpxor ymm7,ymm7,ymm3
add eax,DWORD[((-116))+r13]
lea eax,[rbx*1+rax]
vpxor ymm7,ymm7,ymm0
vmovdqu ymm11,YMMWORD[32+r14]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
vpxor ymm7,ymm7,ymm8
add eax,r12d
xor ebp,edx
add esi,DWORD[((-96))+r13]
vpsrld ymm8,ymm7,30
vpslld ymm7,ymm7,2
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
vpor ymm7,ymm7,ymm8
add edx,DWORD[((-92))+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
vpaddd ymm9,ymm7,ymm11
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[((-88))+r13]
vmovdqu YMMWORD[480+rsp],ymm9
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[((-84))+r13]
mov edi,esi
xor edi,eax
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
and ecx,edi
jmp NEAR $L$align32_2
ALIGN 32
$L$align32_2:
vpalignr ymm8,ymm7,ymm6,8
vpxor ymm0,ymm0,ymm4
add ebp,DWORD[((-64))+r13]
xor ecx,esi
vpxor ymm0,ymm0,ymm1
mov edi,edx
xor edi,esi
lea ebp,[rbp*1+rcx]
vpxor ymm0,ymm0,ymm8
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
vpsrld ymm8,ymm0,30
vpslld ymm0,ymm0,2
add ebp,r12d
and ebx,edi
add eax,DWORD[((-60))+r13]
xor ebx,edx
mov edi,ecx
xor edi,edx
vpor ymm0,ymm0,ymm8
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
vpaddd ymm9,ymm0,ymm11
add eax,r12d
and ebp,edi
add esi,DWORD[((-56))+r13]
xor ebp,ecx
vmovdqu YMMWORD[512+rsp],ymm9
mov edi,ebx
xor edi,ecx
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
and eax,edi
add edx,DWORD[((-52))+r13]
xor eax,ebx
mov edi,ebp
xor edi,ebx
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
and esi,edi
add ecx,DWORD[((-32))+r13]
xor esi,ebp
mov edi,eax
xor edi,ebp
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
and edx,edi
vpalignr ymm8,ymm0,ymm7,8
vpxor ymm1,ymm1,ymm5
add ebx,DWORD[((-28))+r13]
xor edx,eax
vpxor ymm1,ymm1,ymm2
mov edi,esi
xor edi,eax
lea ebx,[rdx*1+rbx]
vpxor ymm1,ymm1,ymm8
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
vpsrld ymm8,ymm1,30
vpslld ymm1,ymm1,2
add ebx,r12d
and ecx,edi
add ebp,DWORD[((-24))+r13]
xor ecx,esi
mov edi,edx
xor edi,esi
vpor ymm1,ymm1,ymm8
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
vpaddd ymm9,ymm1,ymm11
add ebp,r12d
and ebx,edi
add eax,DWORD[((-20))+r13]
xor ebx,edx
vmovdqu YMMWORD[544+rsp],ymm9
mov edi,ecx
xor edi,edx
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
and ebp,edi
add esi,DWORD[r13]
xor ebp,ecx
mov edi,ebx
xor edi,ecx
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
and eax,edi
add edx,DWORD[4+r13]
xor eax,ebx
mov edi,ebp
xor edi,ebx
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
and esi,edi
vpalignr ymm8,ymm1,ymm0,8
vpxor ymm2,ymm2,ymm6
add ecx,DWORD[8+r13]
xor esi,ebp
vpxor ymm2,ymm2,ymm3
mov edi,eax
xor edi,ebp
lea ecx,[rsi*1+rcx]
vpxor ymm2,ymm2,ymm8
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
vpsrld ymm8,ymm2,30
vpslld ymm2,ymm2,2
add ecx,r12d
and edx,edi
add ebx,DWORD[12+r13]
xor edx,eax
mov edi,esi
xor edi,eax
vpor ymm2,ymm2,ymm8
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
vpaddd ymm9,ymm2,ymm11
add ebx,r12d
and ecx,edi
add ebp,DWORD[32+r13]
xor ecx,esi
vmovdqu YMMWORD[576+rsp],ymm9
mov edi,edx
xor edi,esi
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
and ebx,edi
add eax,DWORD[36+r13]
xor ebx,edx
mov edi,ecx
xor edi,edx
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
and ebp,edi
add esi,DWORD[40+r13]
xor ebp,ecx
mov edi,ebx
xor edi,ecx
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
and eax,edi
vpalignr ymm8,ymm2,ymm1,8
vpxor ymm3,ymm3,ymm7
add edx,DWORD[44+r13]
xor eax,ebx
vpxor ymm3,ymm3,ymm4
mov edi,ebp
xor edi,ebx
lea edx,[rax*1+rdx]
vpxor ymm3,ymm3,ymm8
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
vpsrld ymm8,ymm3,30
vpslld ymm3,ymm3,2
add edx,r12d
and esi,edi
add ecx,DWORD[64+r13]
xor esi,ebp
mov edi,eax
xor edi,ebp
vpor ymm3,ymm3,ymm8
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
vpaddd ymm9,ymm3,ymm11
add ecx,r12d
and edx,edi
add ebx,DWORD[68+r13]
xor edx,eax
vmovdqu YMMWORD[608+rsp],ymm9
mov edi,esi
xor edi,eax
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
and ecx,edi
add ebp,DWORD[72+r13]
xor ecx,esi
mov edi,edx
xor edi,esi
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
and ebx,edi
add eax,DWORD[76+r13]
xor ebx,edx
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[96+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
add edx,DWORD[100+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[104+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[108+r13]
lea r13,[256+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[((-128))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[((-124))+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[((-120))+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
add edx,DWORD[((-116))+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[((-96))+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[((-92))+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[((-88))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[((-84))+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[((-64))+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
add edx,DWORD[((-60))+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[((-56))+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[((-52))+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[((-32))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[((-28))+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[((-24))+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
add edx,DWORD[((-20))+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
add edx,r12d
lea r13,[128+r9]
lea rdi,[128+r9]
cmp r13,r10
cmovae r13,r9
add edx,DWORD[r8]
add esi,DWORD[4+r8]
add ebp,DWORD[8+r8]
mov DWORD[r8],edx
add ebx,DWORD[12+r8]
mov DWORD[4+r8],esi
mov eax,edx
add ecx,DWORD[16+r8]
mov r12d,ebp
mov DWORD[8+r8],ebp
mov edx,ebx
mov DWORD[12+r8],ebx
mov ebp,esi
mov DWORD[16+r8],ecx
mov esi,ecx
mov ecx,r12d
cmp r9,r10
je NEAR $L$done_avx2
vmovdqu ymm6,YMMWORD[64+r14]
cmp rdi,r10
ja NEAR $L$ast_avx2
vmovdqu xmm0,XMMWORD[((-64))+rdi]
vmovdqu xmm1,XMMWORD[((-48))+rdi]
vmovdqu xmm2,XMMWORD[((-32))+rdi]
vmovdqu xmm3,XMMWORD[((-16))+rdi]
vinserti128 ymm0,ymm0,XMMWORD[r13],1
vinserti128 ymm1,ymm1,XMMWORD[16+r13],1
vinserti128 ymm2,ymm2,XMMWORD[32+r13],1
vinserti128 ymm3,ymm3,XMMWORD[48+r13],1
jmp NEAR $L$ast_avx2
ALIGN 32
$L$ast_avx2:
lea r13,[((128+16))+rsp]
rorx ebx,ebp,2
andn edi,ebp,edx
and ebp,ecx
xor ebp,edi
sub r9,-128
add esi,DWORD[((-128))+r13]
andn edi,eax,ecx
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
and eax,ebx
add esi,r12d
xor eax,edi
add edx,DWORD[((-124))+r13]
andn edi,esi,ebx
add edx,eax
rorx r12d,esi,27
rorx eax,esi,2
and esi,ebp
add edx,r12d
xor esi,edi
add ecx,DWORD[((-120))+r13]
andn edi,edx,ebp
add ecx,esi
rorx r12d,edx,27
rorx esi,edx,2
and edx,eax
add ecx,r12d
xor edx,edi
add ebx,DWORD[((-116))+r13]
andn edi,ecx,eax
add ebx,edx
rorx r12d,ecx,27
rorx edx,ecx,2
and ecx,esi
add ebx,r12d
xor ecx,edi
add ebp,DWORD[((-96))+r13]
andn edi,ebx,esi
add ebp,ecx
rorx r12d,ebx,27
rorx ecx,ebx,2
and ebx,edx
add ebp,r12d
xor ebx,edi
add eax,DWORD[((-92))+r13]
andn edi,ebp,edx
add eax,ebx
rorx r12d,ebp,27
rorx ebx,ebp,2
and ebp,ecx
add eax,r12d
xor ebp,edi
add esi,DWORD[((-88))+r13]
andn edi,eax,ecx
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
and eax,ebx
add esi,r12d
xor eax,edi
add edx,DWORD[((-84))+r13]
andn edi,esi,ebx
add edx,eax
rorx r12d,esi,27
rorx eax,esi,2
and esi,ebp
add edx,r12d
xor esi,edi
add ecx,DWORD[((-64))+r13]
andn edi,edx,ebp
add ecx,esi
rorx r12d,edx,27
rorx esi,edx,2
and edx,eax
add ecx,r12d
xor edx,edi
add ebx,DWORD[((-60))+r13]
andn edi,ecx,eax
add ebx,edx
rorx r12d,ecx,27
rorx edx,ecx,2
and ecx,esi
add ebx,r12d
xor ecx,edi
add ebp,DWORD[((-56))+r13]
andn edi,ebx,esi
add ebp,ecx
rorx r12d,ebx,27
rorx ecx,ebx,2
and ebx,edx
add ebp,r12d
xor ebx,edi
add eax,DWORD[((-52))+r13]
andn edi,ebp,edx
add eax,ebx
rorx r12d,ebp,27
rorx ebx,ebp,2
and ebp,ecx
add eax,r12d
xor ebp,edi
add esi,DWORD[((-32))+r13]
andn edi,eax,ecx
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
and eax,ebx
add esi,r12d
xor eax,edi
add edx,DWORD[((-28))+r13]
andn edi,esi,ebx
add edx,eax
rorx r12d,esi,27
rorx eax,esi,2
and esi,ebp
add edx,r12d
xor esi,edi
add ecx,DWORD[((-24))+r13]
andn edi,edx,ebp
add ecx,esi
rorx r12d,edx,27
rorx esi,edx,2
and edx,eax
add ecx,r12d
xor edx,edi
add ebx,DWORD[((-20))+r13]
andn edi,ecx,eax
add ebx,edx
rorx r12d,ecx,27
rorx edx,ecx,2
and ecx,esi
add ebx,r12d
xor ecx,edi
add ebp,DWORD[r13]
andn edi,ebx,esi
add ebp,ecx
rorx r12d,ebx,27
rorx ecx,ebx,2
and ebx,edx
add ebp,r12d
xor ebx,edi
add eax,DWORD[4+r13]
andn edi,ebp,edx
add eax,ebx
rorx r12d,ebp,27
rorx ebx,ebp,2
and ebp,ecx
add eax,r12d
xor ebp,edi
add esi,DWORD[8+r13]
andn edi,eax,ecx
add esi,ebp
rorx r12d,eax,27
rorx ebp,eax,2
and eax,ebx
add esi,r12d
xor eax,edi
add edx,DWORD[12+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[32+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[36+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[40+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[44+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[64+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
vmovdqu ymm11,YMMWORD[((-64))+r14]
vpshufb ymm0,ymm0,ymm6
add edx,DWORD[68+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[72+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[76+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[96+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[100+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
vpshufb ymm1,ymm1,ymm6
vpaddd ymm8,ymm0,ymm11
add esi,DWORD[104+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
add edx,DWORD[108+r13]
lea r13,[256+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[((-128))+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[((-124))+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[((-120))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
vmovdqu YMMWORD[rsp],ymm8
vpshufb ymm2,ymm2,ymm6
vpaddd ymm9,ymm1,ymm11
add eax,DWORD[((-116))+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[((-96))+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
add edx,DWORD[((-92))+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
xor esi,ebx
add ecx,DWORD[((-88))+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[((-84))+r13]
mov edi,esi
xor edi,eax
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
and ecx,edi
vmovdqu YMMWORD[32+rsp],ymm9
vpshufb ymm3,ymm3,ymm6
vpaddd ymm6,ymm2,ymm11
add ebp,DWORD[((-64))+r13]
xor ecx,esi
mov edi,edx
xor edi,esi
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
and ebx,edi
add eax,DWORD[((-60))+r13]
xor ebx,edx
mov edi,ecx
xor edi,edx
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
and ebp,edi
add esi,DWORD[((-56))+r13]
xor ebp,ecx
mov edi,ebx
xor edi,ecx
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
and eax,edi
add edx,DWORD[((-52))+r13]
xor eax,ebx
mov edi,ebp
xor edi,ebx
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
and esi,edi
add ecx,DWORD[((-32))+r13]
xor esi,ebp
mov edi,eax
xor edi,ebp
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
and edx,edi
jmp NEAR $L$align32_3
ALIGN 32
$L$align32_3:
vmovdqu YMMWORD[64+rsp],ymm6
vpaddd ymm7,ymm3,ymm11
add ebx,DWORD[((-28))+r13]
xor edx,eax
mov edi,esi
xor edi,eax
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
and ecx,edi
add ebp,DWORD[((-24))+r13]
xor ecx,esi
mov edi,edx
xor edi,esi
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
and ebx,edi
add eax,DWORD[((-20))+r13]
xor ebx,edx
mov edi,ecx
xor edi,edx
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
and ebp,edi
add esi,DWORD[r13]
xor ebp,ecx
mov edi,ebx
xor edi,ecx
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
and eax,edi
add edx,DWORD[4+r13]
xor eax,ebx
mov edi,ebp
xor edi,ebx
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
and esi,edi
vmovdqu YMMWORD[96+rsp],ymm7
add ecx,DWORD[8+r13]
xor esi,ebp
mov edi,eax
xor edi,ebp
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
and edx,edi
add ebx,DWORD[12+r13]
xor edx,eax
mov edi,esi
xor edi,eax
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
and ecx,edi
add ebp,DWORD[32+r13]
xor ecx,esi
mov edi,edx
xor edi,esi
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
and ebx,edi
add eax,DWORD[36+r13]
xor ebx,edx
mov edi,ecx
xor edi,edx
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
and ebp,edi
add esi,DWORD[40+r13]
xor ebp,ecx
mov edi,ebx
xor edi,ecx
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
and eax,edi
vpalignr ymm4,ymm1,ymm0,8
add edx,DWORD[44+r13]
xor eax,ebx
mov edi,ebp
xor edi,ebx
vpsrldq ymm8,ymm3,4
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
vpxor ymm4,ymm4,ymm0
vpxor ymm8,ymm8,ymm2
xor esi,ebp
add edx,r12d
vpxor ymm4,ymm4,ymm8
and esi,edi
add ecx,DWORD[64+r13]
xor esi,ebp
mov edi,eax
vpsrld ymm8,ymm4,31
xor edi,ebp
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
vpslldq ymm10,ymm4,12
vpaddd ymm4,ymm4,ymm4
rorx esi,edx,2
xor edx,eax
vpsrld ymm9,ymm10,30
vpor ymm4,ymm4,ymm8
add ecx,r12d
and edx,edi
vpslld ymm10,ymm10,2
vpxor ymm4,ymm4,ymm9
add ebx,DWORD[68+r13]
xor edx,eax
vpxor ymm4,ymm4,ymm10
mov edi,esi
xor edi,eax
lea ebx,[rdx*1+rbx]
vpaddd ymm9,ymm4,ymm11
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
vmovdqu YMMWORD[128+rsp],ymm9
add ebx,r12d
and ecx,edi
add ebp,DWORD[72+r13]
xor ecx,esi
mov edi,edx
xor edi,esi
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
and ebx,edi
add eax,DWORD[76+r13]
xor ebx,edx
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
vpalignr ymm5,ymm2,ymm1,8
add esi,DWORD[96+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
vpsrldq ymm8,ymm4,4
xor eax,ebx
add esi,r12d
xor eax,ecx
vpxor ymm5,ymm5,ymm1
vpxor ymm8,ymm8,ymm3
add edx,DWORD[100+r13]
lea edx,[rax*1+rdx]
vpxor ymm5,ymm5,ymm8
rorx r12d,esi,27
rorx eax,esi,2
xor esi,ebp
add edx,r12d
vpsrld ymm8,ymm5,31
vmovdqu ymm11,YMMWORD[((-32))+r14]
xor esi,ebx
add ecx,DWORD[104+r13]
lea ecx,[rsi*1+rcx]
vpslldq ymm10,ymm5,12
vpaddd ymm5,ymm5,ymm5
rorx r12d,edx,27
rorx esi,edx,2
vpsrld ymm9,ymm10,30
vpor ymm5,ymm5,ymm8
xor edx,eax
add ecx,r12d
vpslld ymm10,ymm10,2
vpxor ymm5,ymm5,ymm9
xor edx,ebp
add ebx,DWORD[108+r13]
lea r13,[256+r13]
vpxor ymm5,ymm5,ymm10
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
vpaddd ymm9,ymm5,ymm11
xor ecx,esi
add ebx,r12d
xor ecx,eax
vmovdqu YMMWORD[160+rsp],ymm9
add ebp,DWORD[((-128))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
vpalignr ymm6,ymm3,ymm2,8
add eax,DWORD[((-124))+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
vpsrldq ymm8,ymm5,4
xor ebp,ecx
add eax,r12d
xor ebp,edx
vpxor ymm6,ymm6,ymm2
vpxor ymm8,ymm8,ymm4
add esi,DWORD[((-120))+r13]
lea esi,[rbp*1+rsi]
vpxor ymm6,ymm6,ymm8
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
vpsrld ymm8,ymm6,31
xor eax,ecx
add edx,DWORD[((-116))+r13]
lea edx,[rax*1+rdx]
vpslldq ymm10,ymm6,12
vpaddd ymm6,ymm6,ymm6
rorx r12d,esi,27
rorx eax,esi,2
vpsrld ymm9,ymm10,30
vpor ymm6,ymm6,ymm8
xor esi,ebp
add edx,r12d
vpslld ymm10,ymm10,2
vpxor ymm6,ymm6,ymm9
xor esi,ebx
add ecx,DWORD[((-96))+r13]
vpxor ymm6,ymm6,ymm10
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
vpaddd ymm9,ymm6,ymm11
xor edx,eax
add ecx,r12d
xor edx,ebp
vmovdqu YMMWORD[192+rsp],ymm9
add ebx,DWORD[((-92))+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
vpalignr ymm7,ymm4,ymm3,8
add ebp,DWORD[((-88))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
vpsrldq ymm8,ymm6,4
xor ebx,edx
add ebp,r12d
xor ebx,esi
vpxor ymm7,ymm7,ymm3
vpxor ymm8,ymm8,ymm5
add eax,DWORD[((-84))+r13]
lea eax,[rbx*1+rax]
vpxor ymm7,ymm7,ymm8
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
vpsrld ymm8,ymm7,31
xor ebp,edx
add esi,DWORD[((-64))+r13]
lea esi,[rbp*1+rsi]
vpslldq ymm10,ymm7,12
vpaddd ymm7,ymm7,ymm7
rorx r12d,eax,27
rorx ebp,eax,2
vpsrld ymm9,ymm10,30
vpor ymm7,ymm7,ymm8
xor eax,ebx
add esi,r12d
vpslld ymm10,ymm10,2
vpxor ymm7,ymm7,ymm9
xor eax,ecx
add edx,DWORD[((-60))+r13]
vpxor ymm7,ymm7,ymm10
lea edx,[rax*1+rdx]
rorx r12d,esi,27
rorx eax,esi,2
vpaddd ymm9,ymm7,ymm11
xor esi,ebp
add edx,r12d
xor esi,ebx
vmovdqu YMMWORD[224+rsp],ymm9
add ecx,DWORD[((-56))+r13]
lea ecx,[rsi*1+rcx]
rorx r12d,edx,27
rorx esi,edx,2
xor edx,eax
add ecx,r12d
xor edx,ebp
add ebx,DWORD[((-52))+r13]
lea ebx,[rdx*1+rbx]
rorx r12d,ecx,27
rorx edx,ecx,2
xor ecx,esi
add ebx,r12d
xor ecx,eax
add ebp,DWORD[((-32))+r13]
lea ebp,[rbp*1+rcx]
rorx r12d,ebx,27
rorx ecx,ebx,2
xor ebx,edx
add ebp,r12d
xor ebx,esi
add eax,DWORD[((-28))+r13]
lea eax,[rbx*1+rax]
rorx r12d,ebp,27
rorx ebx,ebp,2
xor ebp,ecx
add eax,r12d
xor ebp,edx
add esi,DWORD[((-24))+r13]
lea esi,[rbp*1+rsi]
rorx r12d,eax,27
rorx ebp,eax,2
xor eax,ebx
add esi,r12d
xor eax,ecx
add edx,DWORD[((-20))+r13]
lea edx,[rax*1+rdx]
rorx r12d,esi,27
add edx,r12d
lea r13,[128+rsp]
add edx,DWORD[r8]
add esi,DWORD[4+r8]
add ebp,DWORD[8+r8]
mov DWORD[r8],edx
add ebx,DWORD[12+r8]
mov DWORD[4+r8],esi
mov eax,edx
add ecx,DWORD[16+r8]
mov r12d,ebp
mov DWORD[8+r8],ebp
mov edx,ebx
mov DWORD[12+r8],ebx
mov ebp,esi
mov DWORD[16+r8],ecx
mov esi,ecx
mov ecx,r12d
cmp r9,r10
jbe NEAR $L$oop_avx2
$L$done_avx2:
vzeroupper
movaps xmm6,XMMWORD[((-40-96))+r11]
movaps xmm7,XMMWORD[((-40-80))+r11]
movaps xmm8,XMMWORD[((-40-64))+r11]
movaps xmm9,XMMWORD[((-40-48))+r11]
movaps xmm10,XMMWORD[((-40-32))+r11]
movaps xmm11,XMMWORD[((-40-16))+r11]
mov r14,QWORD[((-40))+r11]
mov r13,QWORD[((-32))+r11]
mov r12,QWORD[((-24))+r11]
mov rbp,QWORD[((-16))+r11]
mov rbx,QWORD[((-8))+r11]
lea rsp,[r11]
$L$epilogue_avx2:
mov rdi,QWORD[8+rsp] ;WIN64 epilogue
mov rsi,QWORD[16+rsp]
ret
$L$SEH_end_sha1_block_data_order_avx2:
section .rdata rdata align=8
ALIGN 64
K_XX_XX:
DD 0x5a827999,0x5a827999,0x5a827999,0x5a827999
DD 0x5a827999,0x5a827999,0x5a827999,0x5a827999
DD 0x6ed9eba1,0x6ed9eba1,0x6ed9eba1,0x6ed9eba1
DD 0x6ed9eba1,0x6ed9eba1,0x6ed9eba1,0x6ed9eba1
DD 0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc
DD 0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc
DD 0xca62c1d6,0xca62c1d6,0xca62c1d6,0xca62c1d6
DD 0xca62c1d6,0xca62c1d6,0xca62c1d6,0xca62c1d6
DD 0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f
DD 0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f
DB 0xf,0xe,0xd,0xc,0xb,0xa,0x9,0x8,0x7,0x6,0x5,0x4,0x3,0x2,0x1,0x0
DB 83,72,65,49,32,98,108,111,99,107,32,116,114,97,110,115
DB 102,111,114,109,32,102,111,114,32,120,56,54,95,54,52,44
DB 32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,60
DB 97,112,112,114,111,64,111,112,101,110,115,115,108,46,111,114
DB 103,62,0
ALIGN 64
section .text
EXTERN __imp_RtlVirtualUnwind
ALIGN 16
se_handler:
push rsi
push rdi
push rbx
push rbp
push r12
push r13
push r14
push r15
pushfq
sub rsp,64
mov rax,QWORD[120+r8]
mov rbx,QWORD[248+r8]
lea r10,[$L$prologue]
cmp rbx,r10
jb NEAR $L$common_seh_tail
mov rax,QWORD[152+r8]
lea r10,[$L$epilogue]
cmp rbx,r10
jae NEAR $L$common_seh_tail
mov rax,QWORD[64+rax]
mov rbx,QWORD[((-8))+rax]
mov rbp,QWORD[((-16))+rax]
mov r12,QWORD[((-24))+rax]
mov r13,QWORD[((-32))+rax]
mov r14,QWORD[((-40))+rax]
mov QWORD[144+r8],rbx
mov QWORD[160+r8],rbp
mov QWORD[216+r8],r12
mov QWORD[224+r8],r13
mov QWORD[232+r8],r14
jmp NEAR $L$common_seh_tail
ALIGN 16
shaext_handler:
push rsi
push rdi
push rbx
push rbp
push r12
push r13
push r14
push r15
pushfq
sub rsp,64
mov rax,QWORD[120+r8]
mov rbx,QWORD[248+r8]
lea r10,[$L$prologue_shaext]
cmp rbx,r10
jb NEAR $L$common_seh_tail
lea r10,[$L$epilogue_shaext]
cmp rbx,r10
jae NEAR $L$common_seh_tail
lea rsi,[((-8-64))+rax]
lea rdi,[512+r8]
mov ecx,8
DD 0xa548f3fc
jmp NEAR $L$common_seh_tail
ALIGN 16
ssse3_handler:
push rsi
push rdi
push rbx
push rbp
push r12
push r13
push r14
push r15
pushfq
sub rsp,64
mov rax,QWORD[120+r8]
mov rbx,QWORD[248+r8]
mov rsi,QWORD[8+r9]
mov r11,QWORD[56+r9]
mov r10d,DWORD[r11]
lea r10,[r10*1+rsi]
cmp rbx,r10
jb NEAR $L$common_seh_tail
mov rax,QWORD[208+r8]
mov r10d,DWORD[4+r11]
lea r10,[r10*1+rsi]
cmp rbx,r10
jae NEAR $L$common_seh_tail
lea rsi,[((-40-96))+rax]
lea rdi,[512+r8]
mov ecx,12
DD 0xa548f3fc
mov rbx,QWORD[((-8))+rax]
mov rbp,QWORD[((-16))+rax]
mov r12,QWORD[((-24))+rax]
mov r13,QWORD[((-32))+rax]
mov r14,QWORD[((-40))+rax]
mov QWORD[144+r8],rbx
mov QWORD[160+r8],rbp
mov QWORD[216+r8],r12
mov QWORD[224+r8],r13
mov QWORD[232+r8],r14
$L$common_seh_tail:
mov rdi,QWORD[8+rax]
mov rsi,QWORD[16+rax]
mov QWORD[152+r8],rax
mov QWORD[168+r8],rsi
mov QWORD[176+r8],rdi
mov rdi,QWORD[40+r9]
mov rsi,r8
mov ecx,154
DD 0xa548f3fc
mov rsi,r9
xor rcx,rcx
mov rdx,QWORD[8+rsi]
mov r8,QWORD[rsi]
mov r9,QWORD[16+rsi]
mov r10,QWORD[40+rsi]
lea r11,[56+rsi]
lea r12,[24+rsi]
mov QWORD[32+rsp],r10
mov QWORD[40+rsp],r11
mov QWORD[48+rsp],r12
mov QWORD[56+rsp],rcx
call QWORD[__imp_RtlVirtualUnwind]
mov eax,1
add rsp,64
popfq
pop r15
pop r14
pop r13
pop r12
pop rbp
pop rbx
pop rdi
pop rsi
ret
section .pdata rdata align=4
ALIGN 4
DD $L$SEH_begin_sha1_block_data_order_nohw wrt ..imagebase
DD $L$SEH_end_sha1_block_data_order_nohw wrt ..imagebase
DD $L$SEH_info_sha1_block_data_order_nohw wrt ..imagebase
DD $L$SEH_begin_sha1_block_data_order_hw wrt ..imagebase
DD $L$SEH_end_sha1_block_data_order_hw wrt ..imagebase
DD $L$SEH_info_sha1_block_data_order_hw wrt ..imagebase
DD $L$SEH_begin_sha1_block_data_order_ssse3 wrt ..imagebase
DD $L$SEH_end_sha1_block_data_order_ssse3 wrt ..imagebase
DD $L$SEH_info_sha1_block_data_order_ssse3 wrt ..imagebase
DD $L$SEH_begin_sha1_block_data_order_avx wrt ..imagebase
DD $L$SEH_end_sha1_block_data_order_avx wrt ..imagebase
DD $L$SEH_info_sha1_block_data_order_avx wrt ..imagebase
DD $L$SEH_begin_sha1_block_data_order_avx2 wrt ..imagebase
DD $L$SEH_end_sha1_block_data_order_avx2 wrt ..imagebase
DD $L$SEH_info_sha1_block_data_order_avx2 wrt ..imagebase
section .xdata rdata align=8
ALIGN 8
$L$SEH_info_sha1_block_data_order_nohw:
DB 9,0,0,0
DD se_handler wrt ..imagebase
$L$SEH_info_sha1_block_data_order_hw:
DB 9,0,0,0
DD shaext_handler wrt ..imagebase
$L$SEH_info_sha1_block_data_order_ssse3:
DB 9,0,0,0
DD ssse3_handler wrt ..imagebase
DD $L$prologue_ssse3 wrt ..imagebase,$L$epilogue_ssse3 wrt ..imagebase
$L$SEH_info_sha1_block_data_order_avx:
DB 9,0,0,0
DD ssse3_handler wrt ..imagebase
DD $L$prologue_avx wrt ..imagebase,$L$epilogue_avx wrt ..imagebase
$L$SEH_info_sha1_block_data_order_avx2:
DB 9,0,0,0
DD ssse3_handler wrt ..imagebase
DD $L$prologue_avx2 wrt ..imagebase,$L$epilogue_avx2 wrt ..imagebase
%else
; Work around path_to_url
ret
%endif
```
|
The men's 200 metre butterfly event at the 1980 Summer Olympics was held on 20 July at the Swimming Pool at the Olimpiysky Sports Complex.
Records
Prior to this competition, the existing world and Olympic records were as follows.
Results
Heats
Final
References
B
Men's events at the 1980 Summer Olympics
|
Zamia inermis is a species of plant in the family Zamiaceae. It is endemic to Actopan, Veracruz state, in eastern Mexico. It is a Critically endangered species, threatened by habitat loss.
References
inermis
Endemic flora of Mexico
Flora of Veracruz
Critically endangered biota of Mexico
Critically endangered plants
Taxonomy articles created by Polbot
|
Otis Hudson (born July 19, 1986) is a former American football guard. He was drafted by the Cincinnati Bengals in the fifth round of the 2010 NFL Draft. He played college football at Eastern Illinois.
Early years
Otis was born and raised in the city of Chicago. He used sports as a way to stay out of trouble. He liked playing basketball, football, and baseball. When Hudson was in middle school, he became part of AAU basketball, which was coached by Douglas Keys. He started playing football in 8th grade and realized he had great athletic ability in football. He played on both the varsity offensive line and defensive line, when he was a freshman at John Marshall High School. He also played on the varsity basketball team as the center. When he was a sophomore in high school, he told his parents he wanted to move to the suburbs, because he knew he would have a better opportunity of playing NCAA football. Otis and his family moved to Barrington, IL. He played varsity football and basketball at Barrington High School and graduated in 2005.
He graduated from Eastern Illinois University and helped his team earn All Conference and All Area recognitions. After graduation, he traveled to California to train with Travelle Gaines of Performance Gaines. Gaines always spoke highly of Hudson. "For the 2010 NFL draft, I have been training 24 top prospects, including Otis, and Otis is just as good as everyone I've seen. He has a work ethic that outclasses most and is very cooperative and coachable, which are intangibles you can't teach."
Professional career
Cincinnati Bengals
On July 7, 2010, Hudson agreed to terms on his rookie contract with the Cincinnati Bengals. He was penciled in as the backup right guard. On September 4, 2010, he was waived by the Bengals. He cleared waivers and was re-signed to the Bengals' practice squad.
During the 2011 season, Hudson spent part of the season on the active roster and on the practice squad. Coach Paul Alexander said he was one of the most improved players during summer camp in 2011.
Hudson spent the entire 2012 season on the Bengals' practice squad. On August 10, 2013, after an ankle injury caused Bengals rookie Tanner Hawkinson to be sidelined indefinitely, the Bengals re-signed Hudson. Hudson was later released during final roster cuts.
Kansas City Chiefs
Hudson signed with the Kansas City Chiefs on May 1, 2014. He was released August 25.
Personal life
As of 2021, Otis works at Merrill Lynch as a financial advisor.
References
External links
Cincinnati Bengals bio
Eastern Illinois Panthers bio
1986 births
Living people
American football offensive guards
American football offensive tackles
Cincinnati Bengals players
Eastern Illinois Panthers football players
Kansas City Chiefs players
People from Barrington, Illinois
Players of American football from Cook County, Illinois
|
Action Computer Enterprise, Inc. (ACE), was an American computer company that was active from 1978 to 1990. The company delivered one of the first multi-user-capable microcomputers, the Discovery 1600, in 1978.
History
Foundation (1978–1979)
Action Computer Enterprise was co-founded by four friends, including Herbert L. Siegel (February 27, 1938 – August 16, 2016), Kwok M. Ong, and Wing Chung. Ong, Siegel and the fourth founder had met during their employment at Jet Propulsion Laboratory (JPL) in California, while Chung and Ong had met at their alma mater of University of California, Berkeley. Long before starting ACE, Siegel had served in the Peace Corps, teaching in Ethiopia with his wife for two years in the 1960s before returning to the United States to obtain an M.A. in mathematics at UC Berkeley. After graduation, he worked as a programmer for JPL, the Los Angeles County Registrar-Recorder, and the Los Angeles County General, developing navigation strategies for JPL and their contract for the Voyager program; voter tracking systems for the Registrar-Recorder; and patient identification systems for the County General. Chung meanwhile was an immigrant who lived in Hong Kong post–World War II before moving to the United States to graduate from UC Berkeley and later Columbia University with degrees in mathematics, his master's degree at the latter university sponsored by the IBM Watson Fellowship. Chung moved to New Jersey to work for Roche before convincing his family to invest $50,000 in Action Computer Enterprise, his startup co-founded in 1978 with Siegel and company.
ACE was founded in one of the founder's home garages in Pasadena, California. It soon occupied an office in the city, growing to a staff of 30 in the early 1980s. Siegel was named chairman, while Chung was named vice president of ACE. The company's early days were spent developing what Chung later claimed to be the first multi-user microcomputer on the market. The company branded this computer as the Discovery 1600 and first released it in April 1979.
Discovery 1600 and Discovery 500 (1979–1983)
The Discovery 1600 was an SBC-based microcomputer based on an IEEE-696-compliant S-100-bus backplane. The system could carry one service processor card and up to fifteen user processor cards on its bus, with room to spare for S-100 peripheral cards (so long as they could support port-mapped I/O). The service processor acts as a controller for the S-100 bus and floppy and hard disk drives. User processor cards, on the other hand, provide the means of interaction and multi-user capability, through the use of video terminals plugged into each of their serial ports. Depending on the type of user processor card (variants described below), either vanilla CP/M or CP/M-86 can be run as an independent operating system on each user processor. The assignment of operating systems to each user card was facilitated by Discovery's custom DPOS (Distributed Processing Operating System).
The Discovery 1600's main service processor card (dubbed the dpc-283 processor) features a Zilog Z80A microprocessor with 96 KB of RAM, a DMA controller, one parallel port, and two serial ports. User processor cards came in three forms: the dpc-83U, the dpc-183, and the dpc-186. The dpc-83U runs off a Z80A and features between 64 and 96 KB (later 96 KB standard) of RAM (non-DMA) and two serial ports; each dcp-83U can only be used as a user processor. The dcp-183 and dpc-186 meanwhile may be repurposed as secondary service processor cards for multiprocessing through the use of a special secondary multiprocessing bus on their boards and through their DMA controllers. The dcp-183 runs off a Z80A processor and features 96 KB of RAM (32 KB bank-switchable) and two serial ports. The dpc-186 meanwhile incorporates an Intel 8086—with a socket for an optional Intel 8087 floating-point unit—between 128 KB and 1 MB of RAM, and two asynchronous serial ports.
The first units of the Discovery 1600 were sold to a tobacco-growing business in the Ban Phai district in Thailand. Further units were primarily sold to banks and government institutions in Thailand, with Chung using his father K. S. Chung's connections to secure these customers. By 1983, roughly 2,000 units of the Discovery 1600 had been sold. The Discovery 1600's success spurred the development of the Discovery 500, another multiuser micro released in January 1983. Like the 1600 before it, the Discovery 500 was based on an SBC-on-a-backplane; however, it reduced the number of maximum processor cards to seven, in exchange for beefier optional floppy and hard drives.
D/NET and dissolution (1983–1990)
In selling the Discovery 500, Wing Chung turned his attention to the computer market in mainland China. By 1984, ACE generated $5 million worth of revenue, or one-third of the company's global revenue, from sales to Chinese business. Sales in China were facilitated by ACE's staff of 25 salespeople and service workers in Hong Kong—half of ACE's total number of employees that year.
To keep the Discovery 1600 competitive in the market, in 1983 ACE introduced D/NET, a software and hardware system for the 1600 that facilitated a local area network comprising a star topology of Discovery 1600 computers. Up to 10 Discovery 1600s can be connected, for a total of 150 networked user terminals. The included network operating system is run on the service processor.
In the mid-1980s, Chung left ACE to found another computer startup in La Mirada, California, called Universal Digital Computer Corporation (UDC). ACE went defunct in 1990.
Citations
References
American companies established in 1978
American companies disestablished in 1990
Computer companies established in 1978
Computer companies disestablished in 1990
Defunct companies based in Greater Los Angeles
Defunct computer companies based in California
Defunct computer companies of the United States
Defunct computer hardware companies
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\Games;
class PlayerExperienceInfo extends \Google\Model
{
/**
* @var string
*/
public $currentExperiencePoints;
protected $currentLevelType = PlayerLevel::class;
protected $currentLevelDataType = '';
/**
* @var string
*/
public $kind;
/**
* @var string
*/
public $lastLevelUpTimestampMillis;
protected $nextLevelType = PlayerLevel::class;
protected $nextLevelDataType = '';
/**
* @param string
*/
public function setCurrentExperiencePoints($currentExperiencePoints)
{
$this->currentExperiencePoints = $currentExperiencePoints;
}
/**
* @return string
*/
public function getCurrentExperiencePoints()
{
return $this->currentExperiencePoints;
}
/**
* @param PlayerLevel
*/
public function setCurrentLevel(PlayerLevel $currentLevel)
{
$this->currentLevel = $currentLevel;
}
/**
* @return PlayerLevel
*/
public function getCurrentLevel()
{
return $this->currentLevel;
}
/**
* @param string
*/
public function setKind($kind)
{
$this->kind = $kind;
}
/**
* @return string
*/
public function getKind()
{
return $this->kind;
}
/**
* @param string
*/
public function setLastLevelUpTimestampMillis($lastLevelUpTimestampMillis)
{
$this->lastLevelUpTimestampMillis = $lastLevelUpTimestampMillis;
}
/**
* @return string
*/
public function getLastLevelUpTimestampMillis()
{
return $this->lastLevelUpTimestampMillis;
}
/**
* @param PlayerLevel
*/
public function setNextLevel(PlayerLevel $nextLevel)
{
$this->nextLevel = $nextLevel;
}
/**
* @return PlayerLevel
*/
public function getNextLevel()
{
return $this->nextLevel;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(PlayerExperienceInfo::class, 'Google_Service_Games_PlayerExperienceInfo');
```
|
This is a list of royal commissions in New South Wales, Australia.
Nineteenth century
1860s
Royal Commission of Inquiry into the Condition of the Harbour of Port Jackson (1865–1866)
Royal Commission to enquire into crime in the Braidwood District (1867) (Clarke brothers, bushrangers)
Royal Commission of Enquiry into certain charges referred against and by Mr Farrand, Police Magistrate and Mr Parker, Clerk of Petty Sessions, at Forbes (–)
Royal Commission of Enquiry into certain cases of Alleged Kidnapping of Natives of the Loyalty Islands, in the years 1865–1868; and the state and probable results of Polynesian Immigration (1869)
1870s
Royal Commission of Inquiry into the Working of the present Gold Fields Act and Regulations of New South Wales and into the best means of securing a permanent water supply for the Gold Fields of the Colony (1870–1871)
Royal Commission appointed to inquire into and report upon the working and management of the public charities of the Colony ("Royal Commission into Public Charities"), (1873)
Royal Commission on Oyster Culture ("Oyster Culture Commission"), (1876–1877)
Royal Commission to inquire into and report upon the general management and discipline of the gaol at Berrima ("Berrima Gaol Inquiry Commission"), (1878)
Royal Commission to inquire into and report upon the working of the Real Property Acts (1879)
1880s
Royal Commission of Inquiry into the conduct of Frederick William Meymott (1880)
Royal Commission of Inquiry into the Management of the Quarantine Station North Head and the hulk Faraway ("Rendell Royal Commission"), (1881)
Royal Commission to inquire into the working of the laws and regulations, and to the arrangement made from time to time for the establishment and maintenance of the military forces of New South Wales ("Military Defences Inquiry Commission"), (1881)
Royal Commission to inquire into the expenditure and distribution of £17,100 to the Milburn Creek Copper-mining Company limited.
Royal Commission into the working of the Friendly Societies Act, 37 Vic. No.4 (1881–1882)
Royal Commission on Noxious and Offensive Trades (1882)
Royal Commission on the Conservation of Water (1884–1887)
Royal Commission on Collieries (1886)
Royal Commission into the Bulli Colliery explosion (1887)
Theatres Royal Commission (1887)
Cox Royal Commission (1888)
Royal Intercolonial Rabbit Commission (1888)
Royal Commission into the alleged tampering with letters of John Deasy (1889)
Royal Commission into alleged unfitness of William Meeke Fehon for appointment as one of the Commissioners for Railways ("Fehon Inquiry Commission"), (1889)
1890s
Royal Commission on Strikes (1890–1891)
Darley Royal Commission (1891)
Royal Commission on Alleged Chinese Gambling and Immorality ("Manning Royal Commission"), (1891)
Royal Commission on City and Suburban Railways (1890–1891)
Royal Commission appointed to inquire into the charges against Mr. E.M.G. Eddy, the Chief Commissioner of Railways (1892)
Royal Commission of inquiry into the alleged defectiveness and unsuitability of the Baldwin Locomotives (1892)
Royal Commission of Inquiry into the Civil Service ("Littlejohn Royal Commission"), (1894–1895)
Royal Commission into the Working of the Deeds and Search Branch of the Registrar-General's Department (1893)
Royal Commission of Inquiry into the Coal Mining Regulation Bill (1895)
Royal Commission of Inquiry into the case of George Dean ("George Dean Royal Commission"), (1895)
Royal Commission of Inquiry into the case of Mr Charles Herbert Battye, Inspector of Conditional Purchases, charged with having accepted a bribe (1896)
Royal Commission on City Railway Extension (1896–1897)
Royal Commission into the Albert mining district (1897)
Royal Commission of Inquiry into the cause of the dangers to which vessels carrying coal are said to be peculiarly liable (1896–1897)
Coal Cargoes Further Inquiry Commission (1897–1900)
Royal Commission of Inquiry into the Management of the Metropolitan Water and Sewerage Board (1897)
Royal Commission of Inquiry into the Institution for the Blind, Strathfield (1897–1898)
Royal Commission of Inquiry into the Management of the Marine Board (1897)
Royal Commission of Inquiry into charges by Robert Henry Levien, Esquire, M.P., against certain members of the Legislative Assembly (1898)
Royal Commission of Inquiry into certain allegations concerning the conduct of the Honourable James Henry Young, Secretary for Public Works, during the recent Election for the Hastings and the Macleay Electorate, and into the circumstances and proceedings (1898)
Royal Commission on Sites for the Seat of Government of the Commonwealth (1899–1900)
Twentieth century
1900s
Royal Commission of Inquiry into certain questions relating to the conduct of Mr James Roberts as Tramway Manager (1900)
Royal Commission of Inquiry into the case of William Creswell (1900)
Royal Commission of Inquiry into certain charges preferred against Sub-Treasurer Fowler, West Maitland (1900)
Royal Commission on Primary, Secondary, Technical and other Branches of Education ("Knibbs-Turner Royal Commission"), (1902)
Royal Commission on a Charge against Sergeant James Hogg (1902)
Royal Commission of Inquiry respecting the Mount Kembla Colliery Disaster (1902–1903)
Royal Commission of Inquiry into the Working and Administration of the Government Docks and Workshops at Cockatoo Island (1903)
Royal Commission into Norfolk Island Affairs (1903)
Royal Commission on the Decline of the Birth-Rate and on the Mortality of Infants in New South Wales (1904)
Railway Locomotives Royal Commission (1904)
Royal Commission of Inquiry into the cost of the Cataract Dam (1905)
Royal Commission of Inquiry into the Railway Administration (1905–1906)
Royal Commission of Inquiry into the administration of the Lands Department (1905–1907) (which found Paddy Crick, the former Secretary for Lands, corruptly received payments from a land agent).
Royal Commission on the Federal Navigation Bill (1906)
Royal Commission (No 2) of Inquiry into Claims of Members of New South Wales Contingents in South Africa ("Royal Commission into Boer War veterans") (1907)
Royal Commission on Coal Mining Disputes, Newcastle and Gunnedah Districts (1907–1909)
Royal Commission for the Improvement of the City of Sydney and Its Suburbs (1908)
Forestry Royal Commission (1908)
Royal Commission on Communication between Sydney and North Sydney ("Royal Commission into Sydney Harbour crossing") (1908–1909)
Royal Commission for the Improvement of the City of Sydney and its Suburbs (1908–1909)
Royal Commission into Saturday Half Holiday (1909)
Royal Commission into Coal loader (1909)
1910s
Royal Commission of Inquiry into certain allegations made by Police Constables Mitchell and Styles, against Sergeant Sheehy, and 1st class Constable Boon, in connection with the death of Walter Bosworth in a police cell, at Bathurst on 28 January 1911 ()
Royal Commission of Inquiry into the alleged treatment of Prisoner Joseph Henry Denmead and certain representations made by Thomas Love (1911)
Royal Commission of Inquiry into the Administration of the Fire Brigades Act (1911)
Royal Commission of Inquiry into certain allegations made by Police Constable Fortescue Mitchell and Police Constable Sidney Thomas Styles (1911)
Royal Commission of Inquiry into the best methods of working the thick coal seams in the Maitland-Cessnock District (1911)
Piddington Royal Commission (1911)
Langwell Royal Commission (1911)
Blacket Royal Commission (1912)
Bavin Royal Commission (1912)
Royal Commission of Inquiry into charges preferred against the Minister for Public Works (1912)
Railway locomotives Royal Commission (1912)
Royal Commission into South Maitland coalfields (1912)
Royal Commission into the Administration of the Mental Hospital and the Reception House for the Insane, Darlinghurst (1913)
Piddington Royal Commission (1913)
Thompson Royal Commission (1913)
Royal Commission on the purchase by the Government of the Boorabil Estate and adjoining improvement leases (1914)
Cocks Royal Commission (1914)
Royal Commission of inquiry respecting the Wheat Acquisition Act ("Ferguson Royal Commission"), (1915)
Royal Commission of Inquiry into the Administration of the Dental Board and the Conduct of its Registrar (1915)
Carmichael Royal Commission (1915)
Royal Commission of Inquiry into allegations of corruption in connection with proposed State monopoly of petrol industry (1916)
Royal Commission on the charges made by Richard Price against the Minister for Lands, William Ashford (1917)
Royal Commission of Inquiry into Allegations as to bribery of Mr P.Lamph, a member of the Licensing Court at Bowraville, by Mr G.B. Kritsch, in connection with an application by Mr M. Wallace for a publican's licence at Macksville (1917)
Royal Commission to Enquire into the Public Service of New South Wales (1917–18)
Royal Commission Respecting the Inquiry on the Homebush Abattoirs and the Meat Industry Act, 1915 (1918)
Harvey Royal Commission (1918)
Allard Royal Commission (1918)
Railway time cards Royal Commission (1918)
Allard Royal Commission II (1919)
Campbell Royal Commission (1919)
Greater Newcastle Royal Commission (1919)
Royal Commission respecting the inquiry into the George Georgeson wheat contract (1919)
1920s
Royal Commission of Inquiry into the State Wheat Pool ("Pring Royal Commission"), (1919–1921)
Royal Commission of Inquiry into the Matter of the Trial and Conviction and Sentences Imposed on Charles Reeve and Others (1920)
Royal Commission of Inquiry into certain charges against Messrs. Dooley, Mutch, and Johnston, members of the Legislative Assembly of New South Wales (1920)
Royal Commission of Inquiry into the Coal Mining Industry and the Coal Trade in the State of New South Wales (1919–)
Allard Royal Commission (1920)
Beeby Royal Commission (1920)
Edmunds Royal Commission (1920)
Royal Commission of Inquiry into the Administration of the Returned Soldiers' Settlement Branch, Department of Lands (1920–1921)
Wade Royal Commission (1921)
Royal Commission into Rail gauge in Australia (1921)
Royal Commission on Lunacy Law and Administration (1922–1923)
Royal Commission of Enquiry into the Question of the Constitution of a Harbour Trust to control the administration of the Port of Newcastle (1922–1923)
Royal Commission into Closer Settlement (1924)
Royal Commission of Inquiry into Redistribution of Wards (1924)
Royal Commission of Inquiry into the Railway and Tramway Services (1924)
Campbell Royal Commission (1924)
Royal Commission of Inquiry respecting the conduct of Aldermen of the Municipal Council of Sydney in connection with certain matters ("Lamb Royal Commission"), (1924–1925)
Royal Commission of Inquiry into Certain Allegations regarding the purchase and re-sale of cornsacks by the Minister for Agriculture (1925)
New States Royal Commission of Inquiry ("Cohen Royal Commission") (1924-5)
Allegations concerning the Industrial Commissioner, Mr A B Piddington KC (1927)
Harvey Royal Commission (1927)
Royal Commission into Bunnerong Powerhouse (1928)
Davidson Royal Commission (Campsie busses) (1929)
Royal Commission of Inquiry into the Coal Industry ("Davidson Royal CommissionCoal"), (1929–1930)
Royal Commission into the Parramatta by-election (1929)
1930s
Royal Commission of Inquiry into the Administration of the Newcastle District Abattoir Board (1930)
Shand Royal Commission (1931)
Prior Royal Commission (1931)
Royal Commission of Inquiry into the Administration of the Western Division of New South Wales (1931)
Royal Commission into the Administration of the Milk Act (1931)
Charles Goode (1932)
Royal Commission on Greyhound Racing and Fruit Machines ("Rogers Royal Commission"), (1932)
Royal Commission on matters concerning the promotion and operations of certain companies in New South Wales (1934–1935)
Gepp Royal Commission (1935)
Royal Commission of Inquiry Respecting Areas in the State of New South Wales Suitable for Self-Government as States in the Commonwealth of Australia ("Nicholas Royal Commission"), (1933–1935)
Royal Commission on matters concerning the promotion and operations of certain companies in New South Wales (1935)
Royal Commission into the Price of Bread (1935-6)
Royal Commission into Matters Affecting the Lands Department and Western Lands Commission ("White Royal Commission"), (1935–1936)
Markell Royal Commission (1937)
Royal Commission of Inquiry into Charges of Fraud and Corruption in connection with the Sale of State Industrial Undertakings ("Rogers Royal Commission"), (1937–1938)
Royal Commission of Inquiry into the Fruit Industry of New South Wales (1937–1939)
Royal Commission on Safety and Health of Workers in Coal Mines (1938–1939)
1940s
Royal Commission into the Compulsory Retirement of Employees in Coal and Oil Shale Mines in New South Wales at the age of 60 years (1940–1941)
Royal Commission into whether The Honourable Vernon Haddon Treatt, Minister of Justice for the state of New South Wales, was guilty of any improper conduct in recommending the reduction of a fine imposed upon the Abbco Bread Company Proprietary Limited (1941)
Royal Commission on Local Government Boundaries ("Clancy Royal Commission"), (1945–1946)
Royal Commission of Inquiry into the Gas Industry (1948–1949)
1950s
Royal Commission of Inquiry into the conduct of Mr Frederick Joseph Cahill, MLA, concerning matters relating to the provision of transport facilities by the Department of Railways for the conveyance of magnesite for Non – Metallic Ltd. (1950)
Royal Commission of Inquiry as to the conviction of Frederick Lincoln McDermott for the Murder of William Henry Lavers (1951–1952)
Royal Commission of Inquiry into matters relating to Joshua George Arthur and Reginald Aubrey Doyle (1953)
Royal Commission on Liquor Laws in New South Wales (1951–1954)
Royal Commission of Inquiry into certain matters relating to David Edward Studley-Ruxton (1954)
Royal Commission of Inquiry into statements made by the Auditor-General in his Annual Report for the Year Ended 30 June 1958, concerning the Minister for Housing, the Honourable Abram Landa ("Royal Commission into Abe Landa") (1958)
1960s
Royal Commission of Inquiry in respect of certain matters relating to Callan Park Mental Hospital (1960–1961)
Royal Commission of Inquiry on the Landlord and Tenant (Amendment) Act, 1948, as amended (1960–1961)
Royal Commission into Off-the-Course Betting in New South Wales (1962–1963)
Royal Commission of Inquiry into Rating, Valuation and Local Government Finance (1965–1967)
1970s
Royal Commission on Petroleum (Commonwealth) (1973–1976)
Royal Commission of Inquiry In Respect Of Certain Matters Relating to Allegations of Organised Crime in Clubs ("Moffitt Royal Commission"), (1973–1974)
Royal Commission into New South Wales Prisons ("Nagle Royal Commission"), (1976–1978)
Royal Commission into Drug Trafficking ("Woodward Royal Commission"), (1977–1979)
1980s
Royal Commission of Inquiry into Drug Trafficking ("Stewart Royal Commission"), (1981–1983)
Royal Commission of Inquiry into Certain Committal Proceedings against K.E. Humphreys (1983) ("Street Royal Commission"), informally known as the "Wran Royal Commission".
Royal Commission of Inquiry into the activities of the Nugan Hand Group (1985)
Royal Commission into the former Chelmsford Private Hospital and Mental Health Services in New South Wales ("Chelmsford Royal Commission"), (1989–1990)
Royal Commission into the Arrest, Charging and Withdrawal of Charges against Harold James Blackburn and Matters Associated Therewith ("Blackburn Royal Commission"), (1989–1990)
1990s
Royal Commission into Productivity in the Building Industry in New South Wales ("Gyles Royal Commission"), (1992)
Royal Commission into the New South Wales Police Service ("Wood Royal Commission"), (1994–1997)
Twenty-first century
2010s
Royal Commission into Institutional Responses to Child Sexual Abuse (2013–2017)
See also
Independent Commission Against Corruption (ICAC)
Royal commissions in Australia
List of Australian royal commissions
Notes
References
Further reading
Royal commissions
Australia politics-related lists
Lists of public inquiries
Lists of organisations based in Australia
|
Cystostemon is a genus of flowering plants belonging to the family Boraginaceae.
Its native range is Tropical Africa to Arabian Peninsula.
Species:
Cystostemon barbatus
Cystostemon ethiopicus
Cystostemon heliocharis
Cystostemon hispidissimus
Cystostemon hispidus
Cystostemon intricatus
Cystostemon kissenioides
Cystostemon linearifolius
Cystostemon loveridgei
Cystostemon macranthera
Cystostemon mechowii
Cystostemon medusa
Cystostemon mwinilungensis
Cystostemon socotranus
Cystostemon somaliensis
Cystostemon virescens
References
Boraginaceae
Boraginaceae genera
|
Maurois is a railway station located in the commune of Maurois in the Nord department, France. It is located near the D932 highway. The station is served by TER Hauts-de-France trains (Douai - Saint-Quentin line). There is no passenger building.
See also
List of SNCF stations in Hauts-de-France
References
Railway stations in Nord (French department)
Railway stations in France opened in 1888
|
The MLW RS-18 was an diesel-electric locomotive built by Montreal Locomotive Works between December 1956 and August 1968. It replaced the RS-10 in MLW's catalogue, and production totalled 351 locomotives, to eight customers.
It was the Canadian version of the ALCO RS-11, although MLW did manufacture the RS-11 for Ferrocarriles Nacionales de México.
Canadian National Railway, by far the largest buyer of the RS-18, continued to specify the long hood as the front. By contrast, while all of Canadian Pacific Railway's RS-10s were long-hood-forward, all of their RS-18s were short-hood forward. All of CN and CP's locomotives were delivered with full-height short hoods, as were the first four Pacific Great Eastern Railway, and first Roberval and Saguenay Railway unit. The remaining production was for locomotives with a low short-hood, giving the train crew much better forward vision.
Original owners
Preserved
West Chester Railroad #1803 is an ALCO RS-18 built in 1960 by the Montreal Locomotive Works for the Canadian Pacific Railway and was numbered 8762 . In 1998 it was retired from service by the Canadian Pacific Railroad and was bought by the West Chester Railroad that same year. It was re-numbered as 1803 and repainted into a Brunswick green with a yellow frame stripe. It is currently in service.
See also
List of MLW diesel locomotives
References
Sources
External links
B-B locomotives
RS-18
Railway locomotives introduced in 1956
Standard gauge locomotives of Canada
|
```scala
package com.wavesplatform.utils
import com.typesafe.config.{Config, ConfigFactory, ConfigRenderOptions}
object SystemInformationReporter extends ScorexLogging {
def report(config: Config): Unit = {
val resolved = config.resolve()
val configForLogs = {
val orig = Seq(
"waves",
"metrics"
).foldLeft(ConfigFactory.empty()) { case (r, path) => r.withFallback(resolved.withOnlyPath(path)) }
Seq(
"waves.custom.genesis",
"waves.wallet",
"waves.rest-api.api-key-hash",
"metrics.influx-db"
).foldLeft(orig)(_.withoutPath(_))
}
val renderOptions = ConfigRenderOptions
.defaults()
.setOriginComments(false)
.setComments(false)
.setFormatted(false)
val logInfo: Seq[(String, Any)] = Seq(
"Available processors" -> Runtime.getRuntime.availableProcessors,
"Max memory available" -> Runtime.getRuntime.maxMemory
) ++ Seq(
"os.name",
"os.version",
"os.arch",
"java.version",
"java.vendor",
"java.home",
"java.class.path",
"user.dir",
"sun.net.inetaddr.ttl",
"sun.net.inetaddr.negative.ttl",
"networkaddress.cache.ttl",
"networkaddress.cache.negative.ttl"
).map { x =>
x -> System.getProperty(x)
} ++ Seq(
"Configuration" -> configForLogs.root.render(renderOptions)
)
log.debug(logInfo.map { case (n, v) => s"$n: $v" }.mkString("\n"))
}
}
```
|
The Book of the SubGenius: Being the Divine Wisdom, Guidance, and Prophecy of J.R. "Bob" Dobbs, High Epopt of the Church of the SubGenius, Here Inscribed for the Salvation of Future Generations and in the Hope that Slack May Someday Reign on This Earth () is seen as the "Bible" of the Church of the SubGenius.
It was compiled from the Church's ongoing zine publication The Stark Fist of Removal. It is usually placed in the humor section of most bookstores, though some SubGenius Members are authorized to move it into the religion section instead.
The book has been republished numerous times, by at least two separate publishers. The original edition was published in 1983 by McGraw-Hill, while the re-release of the book (with the current cover illustration) in 1987 was by Simon & Schuster's imprint Fireside Books (, "1st Fireside edition").
References
Further reading
Revelation X : The 'Bob' Apocryphon: Hidden Teachings and Deuterocanonical Texts of J.R. "Bob" Dobbs,
1983 books
Church of the SubGenius
McGraw-Hill books
Satirical books
|
In what was characterized as the worst disaster in the Yukon River's history, the sternwheeler Columbian exploded and burned at Eagle Rock, Yukon, Canada, on 25 September, 1906, killing six men. The steamer was carrying a crew of twenty-five men and a full cargo, including cattle and three tons (2.722 t) of blasting powder destined for the Tantalus coal mine, downriver.
The Columbian was long, wide, and capable of carrying one hundred and seventy-five passengers plus freight. The engine room was long, housing two high-pressure engines. Built in 1898 by John Todd for the Canadian Development Company (CDC), it was the first CDC steamer to arrive at Dawson City that year, carrying two prefabricated steel steamers for the North-West Mounted Police. The Columbian was bought by the British Yukon Navigation Company along with sixteen other CDC steamers in 1901. In 1905, it had been converted to burn coal from the Tantalus Butte Coal Mine.
The accident
On the day of the accident, the Columbian was carrying only one passenger: Ernest Wynstanley, a stowaway who had sneaked aboard, pretending to be the caretaker of the cattle on board. He was to have been thrown off when the ship docked at Tantalus. In addition to the cattle, the Columbian was also carrying one hundred and fifty tons (136.08 t) of vegetables and meat, along with three tons (2.722 t) of blasting powder.
The 1906 season crew included J. O. Williams, captain; H. C. Baughman, mate; A. Borrowman, steward; Lionel Cadogan Cowper, purser; Carl Christianson (shipping on as "J. Smith"), deckhand and coal trimmer; A. D. Lewis, chief engineer; Frank J. Mavis, second engineer; Edward Morgan, fireman; Phil Murray, deckboy; C. D. Phillips, deckboy; C. Smith, purser; Joe Welsh, mate; and John Woods, deckhand.
The explosion happened after Murray passed his illicitly-held loaded rifle to Morgan, so that the fireman could take pot shots at a flock of ducks on the water. Morgan tripped and accidentally discharged the gun into the load of blasting powder stored on deck. Following the ensuing explosion and fire, the captain grounded the ship on shore; those not killed or injured by the blast jumped ashore to safety.
The explosion blew out the sides of the vessel, scattered men and cargo in the water, and in less than five minutes had involved the whole inside of the ship in a mass of seething flame.
—Dawson Daily News, 26 September, 1906
Six men were killed: Morgan and Welsh were killed instantly, Christianson, Murray, and Woods died before help arrived, and Cowper died several days later of his injuries. The entire cargo was also lost. Welsh's body turned up on the river two months later, but no trace of Morgan was ever found.
Rescue
The crew had no provisions and no way to easily go for help. The closest telegraph office was away at Tantalus. A party of three set out on foot; they were overtaken by Captain Williams and Engineer Mavis in a canoe they had borrowed from a woodcutter.
Arriving at Tantalus after midnight, they woke up the telegraph operator who sent out a message about the disaster with no response—all the other operators were asleep. The first to receive the message, at 9:00 a.m. on 26 September, was at Whitehorse. The first ship to arrive at the scene of the explosion was the sternwheeler Victorian, arriving at 7:00 p.m. Captain Williams had returned that morning; Christianson and Woods had died during the night. Murray died shortly after being carried aboard the Victorian.
Another sternwheeler, the Dawson, had been dispatched from Whitehorse with a doctor and nurses aboard. The Dawson had not received the news until 1:00 p.m. on 26 September; at 1:00 a.m. on 27 September, the Dawson took the crew of the Columbian on board and returned to Whitehorse, where Cowper soon died.
Aftermath
A coroner's jury was called to investigate the cause of the Columbian disaster and returned the following verdict:
That these three men came to their deaths as the result of burns received in an explosion of powder on the forward part of the deck of the Steamer Columbian, and further this jury attaches no blame to any of the surviving officers or crew.
—The Weekly Star, 26 October, 1909[sic]
The bodies of Welsh and Morgan had not been recovered at the time of the jury's deliberations; the cause of their disappearance and deaths was not considered by the inquest. The body of Welsh was found in November on a bar in the Yukon River between Tantalus and Five Fingers, about below the site of the disaster. A lynx had been spotted gnawing on something on the bar; Welsh was identified by the buttons remaining on his vest which was still on his body.
After the explosion the boiler and engines were stripped from the wreck and transported to Dawson City; the boiler was installed on the sternwheeler Casca in 1907. The hull, deemed a menace to navigation, was floated downstream and abandoned in "Columbia" slough.
A monument was erected in the Whitehorse cemetery bearing the names of the men who died.
References
External links
Sternwheelers of the Yukon
Photo of the Columbian
Photos of the Columbian
Photo of the wreck of the Columbian
Photo of the memorial in Whitehorse cemetery
1906 disasters in Canada
Explosions in 1906
Columbian
September 1906 events
Disasters in Yukon
Transport disasters in Canada
Columbian
Steamboats of the Yukon River
Columbian
Columbian
Ships sunk by non-combat internal explosions
|
József Navarrete (born 16 December 1965) is a Hungarian fencer, who won a silver medal in the team sabre competition at the 1996 Summer Olympics in Atlanta together with Bence Szabó and Csaba Köves.
References
External links
1965 births
Living people
Hungarian male sabre fencers
Fencers at the 1996 Summer Olympics
Olympic fencers for Hungary
Olympic silver medalists for Hungary
Olympic medalists in fencing
Medalists at the 1996 Summer Olympics
|
Sidney Lerner (December 10, 1930 – January 12, 2021) was an American advertising and marketing industry executive and public health advocate. He was considered one of the original "Mad Men" of the advertising world and later founded Meatless Mondays campaign.
Early life and education
Lerner was born into a Jewish family to Mollie Lebowitz and Louis Lerner in New York City. He was first in his family of immigrant to go to college.
He graduated from the S.I. Newhouse School of Public Communications at Syracuse University in 1953 with a degree in English and journalism. At Syracuse, he served as the editor of "The Syracusan magazine" and was part of the Orange Key junior men's honorary organization.
Advertising career
Considered one of the original "Mad Men" of Madison Avenue, Lerner's advertising and marketing career included work with Norman, Craig & Kummel, and Benton & Bowles advertising agencies as a creative director.
After graduation from Syracuse, Sid served in Army counter intelligence in Japan. Lerner began his career in the mailroom, from where he found a position in the ranks of copywriting at Benton & Bowles. During his career, he represented popular brands from Procter & Gamble, General Foods (Maxwell House), Texaco, Johnson Wax, and Charmin for which he helped created the memorable "Please Don’t Squeeze the Charmin" campaign featuring Mr. Whipple.
In April 1970, Lerner started Sid Lerner Associates, a consulting business for creative advertising and new product development. This business designed, co-produced and marketed licensed tennis, gifts and sporting good products for the gift and stationery trades.
Public health advocacy
Lerner founded Meatless Mondays and Healthy Mondays campaigns in 2003. The program began at the Johns Hopkins Bloomberg School of Public Health, recommending Americans to abstain from meat one day a week for their health and the environment. It became a global movement, taking hold across the U.S. and growing in over 40 countries around the world.
According to Lerner, his father died of heart disease and his own diet was a catalyst for Meatless Mondays. Based on his doctor's advice Lerner modified his meat consumption, treating the protein more like a "condiment" than a main facet of a meal.
Lerner and his wife, Helaine Lerner funded the Lerner Center for Public Health Promotion to conduct, coordinate, and promote population and community health research, education, and outreach at the Maxwell & Newhouse Schools of Syracuse University in 2011, Johns Hopkins Bloomberg School of Public Health in 2014, and Mailman School of Public Health of Columbia University in 2014. He also established endowed positions at Johns Hopkins and NYU Langone to support health promotions.
Lerner was the president of Biorings LLC, which along with Weill Cornell medical researchers, developed non-hormonal contraceptives to prevent HIV transmission.
Lerner served on the Financial Services Leadership Forum Advisory Committee of the New York Public Library in 2010. He also worked with the American Jewish Committee.
Awards
In 2013, Lerner received the George Arents award, Syracuse University's highest alumni honor for "his work in wellness, advertising and philanthropy".
In 2013, Lerner was awarded the Dean's Medal, the School's highest honor, by Johns Hopkins University's Bloomberg School of Public Health for "his vision and leadership in improving the health of the public through the Meatless Monday Campaign".
In 2019, Lerner received an honorary Doctor of Humane Letters degree from Johns Hopkins University.
Works
Lerner wrote six non-fiction books, including:
Death
Lerner died on January 12, 2021, aged 90, at his home in New York City.
References
External links
Monday Campaigns (Meatless Mondays)
Lerner Center for Public Health Promotion at Syracuse University
1930 births
2021 deaths
21st-century American philanthropists
Activists from New York City
American advertising executives
American health activists
American Jews
Burials in New York (state)
Businesspeople from New York City
Jewish American writers
Philanthropists from New York (state)
S.I. Newhouse School of Public Communications alumni
|
Leucothoe axillaris is a shrub native to the southeastern United States, with the common names swamp dog-laurel and coastal dog-hobble. It has been reported from Louisiana, Mississippi, Alabama, Florida, Georgia, North and South Carolina and Virginia. It grows on floodplains in coastal areas at elevations of less than .
Leucothoe axillaris is a branching shrub up to tall. Leaves are up to long. Flowers are white, cylindrical, up to long. Fruit is a dry capsule.
The cultivar = 'Zeblid' has won the Royal Horticultural Society's Award of Garden Merit.
References
Vaccinioideae
Flora of the Southeastern United States
Flora of the Appalachian Mountains
Flora without expected TNC conservation status
|
```go
// +build openbsd
// +build 386 amd64 arm arm64
package pty
type ptmget struct {
Cfd int32
Sfd int32
Cn [16]int8
Sn [16]int8
}
var ioctl_PTMGET = 0x40287401
```
|
Ian Timothy Whitcomb (10 July 1941 – 19 April 2020) was an English entertainer, singer-songwriter, record producer, writer, broadcaster and actor. As part of the British Invasion, his hit song "You Turn Me On" reached number 8 on the Billboard Hot 100 chart in 1965.
He wrote several books on popular music, beginning with After the Ball, published by Penguin Books (Britain) and Simon & Schuster (United States) in 1972. He accompanied his singing by playing the ukulele and, through his records, concerts, and film work, helped to stimulate the revival of interest in the instrument. His re-creation of the music played aboard the in the film of that name won a Grammy Award in 1998 for package design and a nomination for Whitcomb's liner notes (Titanic: Music as Heard on the Fateful Voyage).
Early life
Whitcomb was born in Woking, Surrey, England to Patrick and Eileen (née Burningham). He was the second child of three children. He spent his childhood years in Scarborough, Thorpeness and Putney. His father worked for Whitcomb's grandfather's film company British Screen Classics in the 1920s, eventually co-starring in Mr. Nobody (released by Fox in 1929). His father was a trained pianist and encouraged Whitcomb to also play piano. Growing up, Whitcomb's chief musical inspirations were Phil Harris, Johnnie Ray, Guy Mitchell, Elvis Presley, and George Formby. He was sent away to boarding school in 1949 (Newlands, Seaford, Sussex) at age 8 and there he soon formed a tissue paper-and-comb band to entertain staff and boys with current hits such as "Riders in the Sky".
Music and writing career
At Bryanston, a public school in Dorset, England, Whitcomb began writing comic and other songs. He started a skiffle group in 1957 and then a rock and roll band in 1959. After leaving school, he worked at Harrods and then as an assistant at film studios. With his younger brother Robin on drums, he formed a band, The Ragtime Suwanee Six, that played at parties in the Surrey area and was managed by Denny Cordell, later to produce records by Procol Harum and Joe Cocker. Robin went on to play tambourine on Sonny & Cher's hit "I Got You Babe" (1965).
Around 1963, while studying history at Trinity College, Dublin, Whitcomb became a founding member and lead vocalist of Dublin's early rhythm and blues band, Bluesville. After some unreleased early recordings, Whitcomb travelled to Seattle, where he performed and was signed to record for Jerden Records. After returning to Dublin, he recorded "This Sporting Life", written by Brownie McGhee and previously recorded as a skiffle number by Chas McDevitt. Whitcomb's recording was then licensed to the Tower label, a subsidiary of Capitol Records, for release in the US. It reached number 100 for one week on the Billboard Hot 100.
Their next record release, again credited as Ian Whitcomb & Bluesville, "You Turn Me On", was largely improvised at the end of a recording session in Dublin. Released as a single on the Tower label, it reached Billboard's number 8 spot in July 1965 – it was the first Irish-produced record to reach the US charts – but did not chart in Britain. During his summer vacation in 1965, Whitcomb went to America to appear on such television programs as Shindig, Hollywood A Go-Go and American Bandstand. Whitcomb played the Hollywood Bowl with The Beach Boys in 1965 and then toured with The Rolling Stones, The Kinks, and Sam the Sham and the Pharaohs.
"N-E-R-V-O-U-S!", Whitcomb's next release, was recorded in Hollywood and reached No. 59 in Billboard and No. 47 in Cash Box. He returned to Dublin for his history finals and received a BA degree. In 1966 he turned to early popular song: His version of a 1916 Al Jolson comedy number, "Where Did Robinson Crusoe Go with Friday on Saturday Night?" was a West Coast hit, reviving the ukulele before the emergence of Tiny Tim.
After making four albums for the Tower label, Whitcomb retired as a pop performer, later writing that he "wanted no part of the growing pretentiousness of rock with its mandatory drugs and wishy-washy spiritualism and its increasing loud and metallic guitar sounds." However, in 1969 he produced Mae West on her album called Great Balls of Fire for MGM Records. He then returned to the UK and was commissioned by Penguin Books to write a history of pop music, After the Ball, published in 1972. He appeared on several BBC TV shows and was an early presenter of the BBC show The Old Grey Whistle Test in 1971.
Whitcomb settled in California in the late 1970s. He starred in and wrote L.A.–My Home Town (BBC TV; 1976) and Tin Pan Alley (PBS; 1974). He wrote Tin Pan Alley, A Pictorial History (1919–1939) and a novel, Lotusland: A Story of Southern California, published in 1979. He also provided the music for a documentary film, Bugs Bunny: Superstar (UA), which was narrated by Orson Welles. For Play-Rite Music he cut 18 piano rolls that were included in an album, Pianomelt. His other albums reflected his research into the genres of ragtime, Tin Pan Alley, vaudeville and music hall. These, beginning with Under the Ragtime Moon (1972), were released on several record labels including Warner Bros. Records, United Artists and Decca Records. During that time he also wrote and produced singles for Warner Bros.' country division, most notably "Hands", a massage parlour story, and "A Friend of a Friend of Mine".
In the 1980s Whitcomb published Rock Odyssey: A Chronicle of the Sixties: Ian Whitcomb, a memoir of the 1960s and described by The New York Times as the best personal account of this period. He also published Ragtime America (Limelight Editions, 1988), followed by a memoir of life as a British expatriate in Los Angeles, Resident Alien (Century, 1990). He wrote extensively on music, culture, and books for a diverse range of magazines including Radio Times, the Los Angeles Times, The Daily Telegraph, The London Magazine. He produced a British documentary on black music, Legends of Rhythm and Blues (part of the series Repercussions, made by Third Eye Productions for Channel Four in 1984). He also hosted a radio show in Los Angeles for 15 years, taking the program from KROQ-FM to KCRW and finally to KPCC-FM.
He continued recording, producing a series of CD collections: Treasures of Tin Pan Alley, Al Jolson songs, and Titanic- Music As Heard On The Fateful Voyage. His liner notes were nominated for a Grammy. His songs are heard in the films Bloody Movie (1987), Cold Sassy Tree (1989), Encino Man (1992), Grass (1999), Man of the Century (1999), Stanley's Gig (2000), After the Storm (2001), The Cat's Meow (2002), Last Call (2002), Sleep Easy, Hutch Rimes (2002), Lonesome Jim (2005) and Fido (2006).
Later life
Whitcomb lived in Southern California with his wife, Regina (née Enzer), and their dog, Toby. He performed, on accordion and ukulele, at music festivals and major venues throughout America, often with his ragtime band, The Bungalow Boys, as well as with a larger orchestra. He continued writing, and made frequent guest appearances. He notably performed live and on recordings as a special guest of ukulele chanteuse Janet Klein's Parlour Boys. He was a regular performer at Cantalini's Restaurant in Playa del Rey, California. He appeared as Grand Marshal in the 24th Occasional Pasadena Doo Dah Parade on November 19, 1999.
From November 2007, he had an internet radio program on Wednesday evenings from 8:00 p.m. until 10:00 p.m.(PST) at Luxuria Music. He signed with Premiere Radio Networks in September 2010 to launch The Ian Whitcomb Show on XM satellite radio, Channel 24. He was named as a BEST OF L.A. in 2008 by Los Angeles magazine.
In 2009 Whitcomb wrote and, with his Bungalow Boys, performed original music for the West Coast Premiere of The Jazz Age, a play by Allan Knee, at the Blank Theater Company's 2nd Stage Theater in Los Angeles, for which he was nominated for an L.A. Theater Award.
As an educator, Whitcomb lectured on early American popular song and composers throughout the California library system. He was a favorite speaker at the annual Oregon Festival of American Music and at the Workman and Temple Families Homestead Museum.
Illness and death
Whitcomb died in Pasadena, California at a care facility on 19 April 2020, from complications of a stroke he had suffered in 2012. He was 78.
Selected discography
Singles
Albums
1965 You Turn Me On (Billboard #125—Tower T (Mono)/ST (Stereo) 5004)
1966 Ian Whitcomb's Mod, Mod Music Hall (Tower T/ST 5042)
1967 Yellow Underground (Tower T/ST 5071)
1968 Sock Me Some Rock (Tower SDT 5100)
1970 On the Pier (World Record Club/EMI ST 1010)
1972 Under the Ragtime Moon (United Artists UAS 29403)
1972 Great Balls of Fire (Mae West album)UK (MGM 235207):(Liner notes credits:"Piano/conceived/produced/directed by Ian Whitcomb in Hollywood").
1973 You Turn Me On (Ember Records NR 5065)
1974 Hip Hooray for Neville Chamberlain! (Argo/Decca 2DA 162)
1976 Crooner Tunes (First American 7704)
1976 Treasures of Tin Pan Alley (Audiophile AP 115)
1977 Ian Whitcomb's Red Hot Blue Heaven (Warner Bros. K56347)
1979 Ian Whitcomb: The Rock & Roll Years (First American FA 7729)
1980 At The Ragtime Ball (Audiophile AP 147)
1980 Instrumentals (First American FA 7751)
1980 Pianomelt (Sierra Briar SRAS 8708)
1981 In Hollywood! (First American FA 7789)
1982 Don’t Say Goodbye, Miss Ragtime (with Dick Zimmerman) (Stomp Off SOS 1017)
1983 My Wife is Dancing Mad (with Dick Zimmerman) (Stomp Off SOS 1049)
1983 The Boogie Woogie Jungle Snake (ITW Records 01)
1984 Rag Odyssey (Meteor Records MTM-006)
1984 On The Street of Dreams (ITW Records 03)
1986 The Best of Ian Whitcomb (Rhino Records RNLP 127)
1986 Oceans of Love (ITW Records 04)
1987 Steppin’ Out (Audiophile AP 225)
1987 Ian Whitcomb's Ragtime America (Premier PMP 1017)
1990 All the Hits Plus More (Prestige/BBC PRST 005)
Compact discs
1988 Happy Days Are Here Again (Audiophile ACD 242)
1992 Ian Whitcomb’s Ragtime America (ITW 009)
1995 Lotusland—A New Kind of Old-Fashioned Musical Comedy (Audiophile ACD 283)
1996 Let the Rest of the World Go By (Audiophile ACD 267)
1997 The Golden Age of Lounge (Varèse Sarabande VSD 5821)
1997 Ian Whitcomb: You Turn Me On!/Mod Mod Music Hall (Sundazed SC 11044)
1997 Titanic: Music as Heard on the Fateful Voyage (Rhino R2 72821)
1998 Spread a Little Happiness (Audiophile ACD 249)
1998 Titanic Tunes—A Sing-A-Long in Steerage (The Musical Murrays Conducted by Ian Whitcomb) (Varèse Sarabande 5965)
1998 Songs from the Titanic Era (The New White Star Orchestra) (Varèse Sarabande VSF 5966)
1999 Comedy Songs (Audiophile ACD 163)
2001 Sentimentally Yours (Woodpecker Records)
2002 Dance Hall Days (ITW Records)
2003 Under the Ragtime Moon (Vivid Sound B00008WD18)
2005 Old Chestnuts & Rare Treats (ITW Records)
2005 Words & Music (ITW Records)
2006 Lone Pine Blues (Vivid Sound NACD3229; Japanese import only)
2011 Now and Then (Cayenne Music)
2011 I Love A Piano (Rivermont BSW-2218) with Adam Swanson
2012 Songs Without Words (Rivermont BSW-3136) 2-CD set
2014 The Golden Age of Tin Pan Alley (Rivermont BSW-3137) 2-CD set
Books
1972 After the Ball: Pop Music from Rag to Rock (Allen Lane/Penguin) .
1973 20th Century Fun Essex Music
1975 Tin Pan Alley: A Pictorial History (Paddington Press) ASIN: B000RC8WOC
1979 Lotusland: A Story of Southern California (Wildwood House)
1982 Whole Lotta Shakin’: A Rock ‘n’ Roll Scrapbook (Arrow) ASIN: B000OHDDPI
1983 Rock Odyssey: A Chronicle of the Sixties (Doubleday/Anchor)
1986 Irving Berlin & Ragtime America (Arrow)
1990 Resident Alien (Century)
1994 The Beckoning Fairground: Notes of a British Exile (California Classics)
1994 Treasures of Tin Pan Alley (Mel Bay)
1995 Vaudeville Favorites (Mel Bay)
1996 The Best of Vintage Dance (Mel Bay)
1997 Songs of the Ragtime Era (Mel Bay)
1998 The Titanic Songbook (Mel Bay)
1998 Titanic Tunes (Mel Bay)
1998 Songs of the Jazz Age (Mel Bay)
1999 Ukulele Heaven (Mel Bay)
2001 Uke Ballads (Mel Bay)
2003 The Cat's Meow (Mel Bay)
2007 The Ian Whitcomb Songbook (Mel Bay)
2009 Letters From Lotusland (Wild Shore Press)
2011 Ian Whitcomb's Ukulele Sing-Along (Alfred Music Publishing) (Book & CD)
2012 Ukulele Heroes: The Golden Age (Hal Leonard)
Appearances
Screen
1997 Contact
2000 Stanley's Gig
2004 Open House
2011 6 1/2 Weeks
2012 Forbidden Lovers
2012 Table For Twelve
2012 His Mother's Lover
2013 Lesbian One Night Stand
2014 His Lover's Son
Television
1965 Thank Your Lucky Stars
1965 Shindig
1965 Hollywood A Go-Go
1965 Shivaree
1965 Where the Action Is
1967 The Pat Boone Show
1971 The Old Grey Whistle Test
1973 Today
1975 The Tonight Show Starring Johnny Carson
1975 The Merv Griffin Show
1976 The Late Late Show
1977 L.A–My Home Town
1979 Tomorrow
1985 Don't Say Good Bye, Miss Ragtime
1997 The Weird Al Show
2010 Ave 43
Notes
The New York Times, 26 April 1998.
The New York Times, 22 January 1984
References
External links
Ian Whitcomb's website
Travis Elborough, "Ian Whitcomb – Resident Englishman", The Dabbler, 21 April 2015
1941 births
2020 deaths
British ukulele players
English male singers
English male singer-songwriters
English record producers
English expatriates in the United States
People from Woking
Alumni of Trinity College Dublin
People educated at Bryanston School
|
Smoky the Bar is an album by country music artist Hank Thompson and the Brazos Valley Boys. It was released in 1969 by Dot Records (catalog no. DLP-25932). Joe Allison was the producer. It is an album of songs related to drinking, partying, and bars.
AllMusic gave the album a rating of four-and-a-half stars. Reviewer Thom Jurek concluded: "This is one of Thompson's finest works from top to bottom and should be sought out by every fan of great 1960s country music."
The album debuted on Billboard magazine's Top Country Albums chart on May 17, 1969, peaked at No. 16, and remained on the chart for a total of 15 weeks.
Track listing
Side A
"Smoky the Bar" (Joe Penix, Hank Thompson) [2:25]
"Ace in the Hole" (Hank Thompson, Merle Travis) [2:35]
"Let's Get Drunk and Be Somebody" (Hank Thompson) [2:26]
"New Records on the Jukebox" (Jet Penix, Hank Thompson) [2:40]
"My Rough and Rowdy Ways" (Elsie McWilliams, Jimmie Rodgers) [2:20]
"Cocaine Blues"
Side B
"I See Them Everywhere" (Hank Thompson) [2:04]
"Drunkard's Blues" (Hank Thompson) [3:46]
"What's Made Milwaukee Famous (Has Mad a Loser Out of Me)" (Glenn Sutton) [2:09]
"Girl in the Night" (Hank Thompson) [3:05]
"Bright Lights and Blonde Haired Women" (Eddie Kirk) [2:37]
"Pop a Top" (Nat Stuckey) [2:20]
References
1969 albums
Hank Thompson (musician) albums
Dot Records albums
|
```smalltalk
Package { #name : 'UndefinedClasses-Tests' }
```
|
Umling Gewog (Dzongkha: ཨུམ་གླིང་) is a gewog (village block) of Sarpang District, Bhutan.
Umling Gewog is situated in the central Southern foothills of Sarpang Dzongkhag, bordering Assam, India, in the
South, and Chuzagang Gewog in the West, Tareythang Gewog in the East and Zhemgang Dzongkhag in the North.
Its total geographical area is approximately , of which is arable land. It has undulated terrain with an elevation ranging from above sea level. It has warm and humid climatic condition in winter and hot and rainy climatic conditions in summer.
It is approximately from the Dungkhag headquarters (Gelephu) and is connected with the farm road which is inaccessible in the monsoon season due to heavy downpour. It has a total population of 3129 with almost 100 percent of the people dependent upon agriculture.
Arecanut and ginger are grown as principal cash crop while paddy and maize are cultivated as main crop by the farmers. Beside farmers also rear domestic animals like cows, oxen, goats, sheep, etc. which ultimately add to their livelihood.
Until 2011 local government election, the Gewog had eight Chiwogs, namely: Chhuborthang, Daangling, Doongmin, Gaden, Lingar, Rijoog, Tashithang and Thongjazor and was merged into five Chiwogs, namely: Daangling, Doongmin, Gaden, Rijoog and Tashithang after the first LG election. The Geog is administratively headed by Gelephu Dungkhag and subsequently by Sarpang Dzongkhag.
References
Sarpang District
|
Bobovik () is a village in Serbia. It is located in the municipality of Vladimirci, in the Mačva District. The population numbered 307 people in a 2002 census.
Populated places in Mačva District
|
```html
<!--
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
-->
<div class="x_panel">
<div class="x_title">
<ol class="breadcrumb pull-left">
<li class="active">Divisions</li>
</ol>
<div class="pull-right">
<button name="createDivisionButton" class="btn btn-primary" title="Create Division" ng-click="createDivision()"><i class="fa fa-plus"></i></button>
<button class="btn btn-default" title="Refresh" ng-click="refresh()"><i class="fa fa-refresh"></i></button>
</div>
<div class="clearfix"></div>
</div>
<div class="x_content">
<br>
<table id="divisionsTable" class="table responsive-utilities jambo_table">
<thead>
<tr class="headings">
<th>Name</th>
</tr>
</thead>
<tbody>
<tr ng-click="editDivision(d.id)" ng-repeat="d in ::divisions">
<td name="name" data-search="^{{::d.name}}$">{{::d.name}}</td>
</tr>
</tbody>
</table>
</div>
</div>
```
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\MyBusinessLodging;
class GetGoogleUpdatedLodgingResponse extends \Google\Model
{
/**
* @var string
*/
public $diffMask;
protected $lodgingType = Lodging::class;
protected $lodgingDataType = '';
/**
* @param string
*/
public function setDiffMask($diffMask)
{
$this->diffMask = $diffMask;
}
/**
* @return string
*/
public function getDiffMask()
{
return $this->diffMask;
}
/**
* @param Lodging
*/
public function setLodging(Lodging $lodging)
{
$this->lodging = $lodging;
}
/**
* @return Lodging
*/
public function getLodging()
{
return $this->lodging;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(GetGoogleUpdatedLodgingResponse::class, your_sha256_hash);
```
|
Hoven, Denmark is a small village in west-central Denmark, with a population of 211 (1 January 2023), on the Jutland Peninsula. Its elevation is 20 meters, and it is 2.8 km from Ørbæk (one of four Ørbæk's in the country), and 2.1 km from Dyrvig. It is located in Ringkøbing-Skjern Municipality at , Central Denmark Region, southwest of Herning. The town has an old church and an old schoolhouse.
References
Cities and towns in the Central Denmark Region
Ringkøbing-Skjern Municipality
|
```xml
const commonParams = `
$name: String,
$action: String,
$params: String,
$config: String,
$scope:String
`;
const commonParamsDef = `
name: $name,
action: $action,
params: $params,
config: $config,
scope: $scope
`;
const addConfig = `
mutation AddGrantConfig(${commonParams}) {
addGrantConfig(${commonParamsDef}) {
name
action
params
createdAt
modifiedAt
}
}
`;
const editConfig = `
mutation EditGrantConfig($_id: String,${commonParams}) {
editGrantConfig(_id: $_id,${commonParamsDef}) {
name
action
params
createdAt
modifiedAt
}
}
`;
const removeConfig = `
mutation RemoveGrantConfig($_id: String) {
removeGrantConfig(_id: $_id)
}
`;
export default { addConfig, editConfig, removeConfig };
```
|
Cyprus Airways (Public) Ltd. (Greek: Κυπριακές Αερογραμμές) was the flag carrier airline of Cyprus. It was established in September 1947 and ceased operations on 9 January 2015. Cyprus Airways had its operating base at Larnaca International Airport.
In July 2016, Charlie Airlines acquired the rights to use the Cyprus Airways trademarks and brand.
History
Early years
Cyprus Airways was established on 24 September 1947 as a joint venture between the British Colonial Government of Cyprus, holding 40% of the share capital, British European Airways (BEA) and private interests owning the rest of the company. Operations commenced on 18 April 1948 with three Douglas DC-3 aircraft. The planes, which carried 21 passengers each, flew on a route network centred on Nicosia that included Rome, London (via Athens), Beirut, Athens, Cairo, Istanbul, and Haifa. During the next three years the airline purchased an additional three DC-3 aircraft and introduced services to Alexandria, Amman, Bahrain, Khartoum (via Haifa) and Lod.
In its early years Cyprus Airways was operated effectively as a subsidiary of BEA, not only in its ownership structure, but in its use of BEA crew and cabin staff, and BEA aircraft. In part this was due to restrictions placed on BEA by the British government on serving destinations further east than Cyprus, as such routes were considered the preserve of BEA's rival, British Overseas Airways Corporation (BOAC), although both BEA and BOAC were state-owned airlines at the time. With its control of Cyprus Airways, BEA was able to serve key destinations in the Middle East, including Beirut and Cairo, using Cyprus Airways, whilst maintaining the pretence of not flying beyond Cyprus. Paradoxically it was continuing disputes between BEA and BOAC over this issue that led to the first proposals in 1953 to merge BEA and BOAC to form British Airways.
In 1952, BEA took over the Cyprus Airways service to London with an Airspeed Ambassador, which featured a pressurized cabin that allowed nonstop routing avoiding a stopover in Athens. On 18 April 1953, BEA began using its newly delivered Vickers Viscount 701 on their scheduled service from London to Rome and Athens. The continuing sector from Athens to Nicosia was operated by BEA under charter to Cyprus Airways. This route from London to Nicosia was the world's first regular turboprop service.
In 1956, contemplating expansion of its routes, Cyprus Airways ordered two Vickers Viscount 756 aircraft that would be named St Hilarion (registration G-APCD) and Buffavento (G-APCE), but sold them before receiving them because of the deteriorating political situation in Cyprus. It also decided to sell all the Douglas DC-3 and Auster aircraft in September 1957 and entered into a five-year agreement with BEA for the latter to operate services on behalf of Cyprus Airways. As a result, BEA took over the operation of all Cyprus Airways services from 26 January 1958.
Independence in 1960
The government of newly independent Cyprus became the majority shareholder in 1960 with a 53.2 percent holding, while BEA's stake was reduced to 22.7 percent and private individuals held the rest. Thereafter, Cypriot nationals began to be hired and trained for the flight crews, which had previously been made up of British expatriates from BEA. Cyprus Airways still relied on BEA for aircraft and backroom support. BEA began introducing Comet 4B jets on all routes in 1961 via a joint aircraft pool arrangement that included Greece's Olympic Airways.
On 5 April 1960, BEA introduced de Havilland Comet 4B aircraft on the Nicosia, Athens, Rome and London routes. With the introduction of the Comets, Cyprus Airways became the first airline in the Middle East to have jet airplanes. The Comets flew in the BEA livery, but had the Cyprus Airways logo and title above their doors.
In 1965, Cyprus Airways began leasing its own Viscounts from BEA for regional routes. The Comet and Viscount aircraft were replaced with five Trident jets, three of them acquired from BEA. The first Hawker Siddeley Trident jet was introduced in November 1969. Cyprus also leased a BAC 1-11. The faster planes allowed more European trade centres (Frankfurt, Manchester, Brussels, and Paris) to be added to the timetable.
1974
At the start of the Turkish invasion of Cyprus in 1974, the attack on Nicosia airport caught all five of Cyprus Airways aircraft on the ground. Of the four Tridents stranded at Nicosia International Airport one was destroyed by Turkish Air force rocket fire and wreckage of its tail still exists at that airport and one was damaged by small arms fire remaining in the same position today as it did in 1974. The two other Tridents were only lightly damaged by small arms fire and were flown out of Nicosia by British Airways engineers to the United Kingdom in 1977. The team from British Airways was assisted by a British Army team from the UN Peace Keeping (UNFICYP) REME Workshop based in Nicosia.
They used their 6x6 Leyland Recovery vehicle to remove the tail section of one of the destroyed planes and to lift the repaired engines into place. When the Tridents flew out (the Turks would not give permission for test flights, once they took off they were not allowed to return) they were the first planes to use the runway since U Thant flew in and out on a UN flight. One of these is at the Imperial War Museum Duxford, England, although it has been returned to its original BEA livery. Also flown out was the company's BAC1-11 which was claimed by the insurers of the lessor, Court-Line, which had gone bankrupt. That aircraft returned to Cyprus Airways in 1978 and served with the company until 1995.
All of the Cypriot airline's operations had to be suspended following the end of the hostilities in 1974 because Nicosia International Airport, the only airport of the island, had to be closed. Although the Turkish troops did not capture it, they were close enough to it to demand that it not be reopened. The government of Cyprus then moved quickly to build a small terminal by a runway in Larnaca and Cyprus Airways restarted limited operations from there on 8 February 1975. Specifically the airline leased from British Midland Airways Viscount turboprops to fly a stripped down route network to a few key cities in the region: Beirut, Tel Aviv, and Athens via Heraklion, with connections to London on British Airways. Cyprus Airways leased a pair of DC-9 jets in August 1975 to resume its own flights to London (via Salonika).
The acquisition of a DC-8 several months later allowed for non-stop service. Cyprus also added flights to Saudi Arabia at this time. The company was soon able to order a pair of new BAC 1-11s, added to the sister aircraft already in the fleet. The economic loss of the Turkish invasion to the airline was estimated to be 1.6 million Cypriot pounds. To survive, the airline decided to reduce the salaries of all its employees to a minimum, who accepted it.
The airline ordered still more different aircraft types in the late 1970s which replaced some earlier aircraft coming off lease.
Expansion in the 1980s
By 1981, Cyprus's fleet included four Boeing 707-123B (1979–1989) and three BAC One-Eleven 500. The route network again extended from Manchester, England, to Baghdad. A change in ownership structure had taken place, with British Airways selling all but 5 percent of the shares it had inherited from BEA to the Cypriot government. Private investors owned the remainder (24.14 percent).
Cyprus made a transition to Airbus aircraft over the course of the decade. Its first A310 widebodies arrived in 1984, followed by A320s in 1989. The order for the eight A320s was worth more than DEM 250 million.
Cyprus Airways was one of the first airlines to operate the Airbus A310, the eighth airline in the world to receive the Airbus A320, and the first airline that launched the IAE V2500 engine along with Adria Airways.
Profits reached record levels in the mid-1980s as the airline added service from new UK cities (Cardiff, Newcastle, and Glasgow). Income of CYP 4.8 million (DEM 8 million) in 1983, a record, would be tripled three years later. By this time, the airline was carrying 740,000 passengers a year.
1990s
British Airways divested the last of its shares in 1991, leaving the government with an 80.46 percent stake and private investors, the remainder. The airline was flying high, introducing a livery and uniforms as the Airbuses plied new routes to Berlin and Helsinki. Cyprus Airways had also joined the SABRE international computer reservations system and set up a tour operation in the United Kingdom.
In 1992 the group established Eurocypria Airlines Ltd. to fly European tourists to Cyprus on a charter basis. It was expanding into ancillary services as well, taking over duty-free operations at Larnaca and Pafos airports.
Cyprus added many new cooperation agreements with other airlines as it developed its international reach by linking Europe and the Middle East. Its partners included KLM and Saudia. By the mid-1990s, more than one million passengers were flying Cyprus Airways every year; another 4,000 chose the charter operation Eurocypria. The airline's market share approached 40 percent. After a rough couple of years, the company posted a CYP 13 million profit in 1994 thanks to cost-cutting and marketing efforts.
New millennium
The airline introduced a restyled livery, as it embarked on an ambitious fleet renewal programme. Two new Airbus A319s, smaller than its other aircraft, were added in 2002. The next year, two new Airbus A330s replaced the older A310s on long-haul routes. A fleet of four Boeing 737s was chosen for the Eurocypria charter subsidiary, however, with two further similar aircraft added in 2004 and 2005. A feature of the new Eurocypria aircraft was that each had a different colour on its tail. In the meantime, the A320s owned by Cyprus Airways but leased to Eurocypria were returned to the parent company.
In 2002, the Cypriot government lowered its ownership stake to 69.62 percent.
Cyprus Airways founded Hellas Jet in Athens (Greece) in 2003, never making a profit. It held a 75% share of that carrier until all of the shares were sold to Air Miles (charter broker) Air Miles in 2005.
In 2006, the government of Cyprus bought Eurocypria because Cyprus Airways started facing severe financial problems.
According to the airline's 2010 financial results the operating loss for 2010 was €4,9 million in comparison to a loss of €5,4 million in 2009. On 28 June 2011 Cyprus Airways issued a profits warning to the Cyprus Stock Exchange, attributing this to "the continuing financial crisis and to the further significant increase in fuel prices."
On 31 August 2011, Cyprus Airways issued its results for the first half of 2011, which showed a loss of €29.3 million, compared to a loss of €25.5 million for the respective period in 2010, representing an increase of €3.8 million.
As a result of a restructuring programme to curb the continued losses, most Middle East destinations were cut from the timetable in 2011/2012, including Bahrain, Cairo, Damascus, Dubai and Jeddah.
Final years and closure
In February 2012, due to the poor financial results of the airline, the Cypriot government announced it would increase the airline's capital and authorized negotiations for the sale of an unspecified stake of the carrier. , Cyprus government owns 93.67% of the airline.
raised the share capital of the company and sold the state-owned majority of shares. Negotiations were developing with Aeroflot, which was expected to buy the company if an agreement is reached with the Cypriot government. In May 2012, Cyprus Airways announced that interest was expressed by Triple Five Group, the first official announcement concerning a bidder for the sale of the company. On 23 July 2012, the Cyprus Stock Exchange suspended dealing in Cyprus Airways shares, due to the delay by Cyprus Airways in submitting and publishing its annual financial statements for the year ended 31 December 2011.
A statement to the Cyprus Stock Exchange on 4 March 2013 gave the results for Cyprus Airways Group for the year ended 31 December 2012 as a loss after tax of €55,8 million in comparison to a loss of €23,9 million in 2011.
The European Commission announced on 6 March 2013 that it has opened an investigation into whether the Cypriot government's €73 million rescue loan in December 2012 and €31.3 million contribution to a capital increase in January 2013 are in breach of EU rules on state aid.
On 13 March 2014 Cyprus Airways confirmed the sale of its second slot at London Heathrow Airport to the Lebanese company Middle East Airlines for €6.3 million.
The airline ceased operations on 9 January 2015 following a policy made by the European Commission that the state aid paid to the airline by the Government of Cyprus was illegal and had to be returned by the company. This effectively caused Cyprus Airways to be bankrupt. Notably, air connectivity rose by 15 per cent in the first six months of 2016 compared with an increase of 3.6 per cent in 2015, the year when Cyprus Airways went into bankruptcy.
Restart of operations
In July 2016, the Cypriot government announced that the Cypriot start-up company Charlie Airlines Ltd was the winning bidder in a competition carried out by the finance ministry about the usage of the Cyprus Airways Brand for a period of ten years. Charlie Airlines has been built by a consortium of local investors that hold 60% of the airline and Russia's S7 Airlines, that holds 40% as a joint-venture. S7 is currently Russia's largest domestic carrier and transported 10.6 million passengers in 2015. S7 CEO Vladislav Filev said that the Charlie name was inspired by the nickname handed to expatriated Cypriots that had left the island. S7 will provide two Airbus A319-100 aircraft to start operations to destinations in the UK, Greece and Russia. Charlie Airlines Ltd filed an application to receive a local Air operator's certificate and acquire the right to use the Cyprus Airways trademarks for ten years for 2 million euros.
Corporate affairs
Ownership
Cyprus Airways Public Ltd was predominantly owned by the government of Cyprus, with 391,155,177 shares issued and fully paid:
Business trends
The key trends for Cyprus Airways are shown below (as at years ending 31 December). Full annual reports and accounts were issued up until 2007, but as the airline's financial position deteriorated, so the annual accounts became briefer. The 2012 figures are only from press reports, and are unaudited.:
*Unaudited figures; loss shown is after tax.
Destinations
, Cyprus Airways served 12-year-round destinations in 10 countries, all in Europe and the Middle East.
Codeshare agreements
, Cyprus Airways had codeshare agreements with the following airlines:
Aeroflot
Air France
Alitalia
Bulgaria Air
Etihad Airways
Gulf Air
KLM
Middle East Airlines
TAROM
Virgin Atlantic
On 25 July 2011, Cyprus Airways signed a code-share agreement with Virgin Atlantic, allowing the Cypriot market to travel to Boston, New York, Newark, Los Angeles, Manchester, Edinburgh and Aberdeen on flights operated by Virgin using both Virgin and Cyprus Airways flight numbers, with connecting flights at London–Heathrow. Services from London Heathrow to Larnaca were operated by Cyprus Airways aircraft with flight numbers both of Cyprus Airways and Virgin Atlantic.
Fleet
Prior to the airline's shutdown, Cyprus Airways had a fleet of fourteen Airbus A320 aircraft of an average age of 11.3 years. All aircraft bore names of Cypriot landmarks and cities.
Past fleet
Cyprus Airways operated the following aircraft types:
Livery
The airline's livery was an all white fuselage with the words 'CYPRUS AIRWAYS' in blue over the front passenger windows. The vertical stabilizer was blue, with yellow lines depicting a galloping Cypriot mouflon, a type of wild sheep only found in Cyprus. This logo was also painted on the engines of the aircraft. The galloping mouflon logo was designed in 1962 by David Collins on the instruction of BEA. The first aircraft to display the mouflon design were De Havilland Comet 4B aircraft by the passenger door entrance.
Catering
Food and beverages served on flights from Cyprus were provided by Cyprus Airways Catering facilities in Larnaca. Meals were selected from an array of international and Cypriot foods.
In-flight entertainment
In-flight entertainment was introduced by Cyprus Airways on its Airbus A319 aircraft upon delivery in 2002, and its A320s were retrofitted at the same time.
On the A320 family aircraft, there were television screens placed along the aircraft. Sound was provided through headsets given by the cabin crew. Screens had a moving-map system which provided real-time flight information such as position and direction of the plane, altitude, airspeed, distance to destination, distance from origination, and local time.
The larger A330 aircraft, operated between 2002 and 2011 and used mainly on longer flights to London Heathrow, Paris, and Amsterdam, but also occasionally to Manchester, Athens, and Zurich, had individual screens for each passenger, mounted on the back of the seats, offering many more options in video and audio entertainment.
Business class
Business class was named after the ancient Greek god Apollo, who was a symbol of harmony, order, and reason. Apollo class had wide leather seats that reclined by up to 45 inches (110 cm) of pitch and featured electrical recline and leg rest. Apollo-class passengers also had access to the Sunjet executive lounges at both Larnaca and Paphos airports.
Apollo class included a personal entertainment system, built into the armrest of the high-standard seats. Additionally, meals were served to business class passengers, with a selection of international and Cypriot cuisine on offer. Drinks and wine were offered on all flights.
Economy class
Economy class was named after the ancient Greek goddess Aphrodite, who, according to Greek mythology, was a symbol of beauty and elegance. Cyprus Airways' Aphrodite (economy) Class offered a seat pitch of 30-31 inches.
Depending on the destination and time of the flight, a hot breakfast, lunch, or cold snack was served. The tray included a seasonal salad and dessert, as well as crackers and halloumi cheese. Drinks, including coffee or tea and soft drinks, were offered.
SunMiles
SunMiles was the frequent flyer programme of Cyprus Airways. There were four tiers of membership: Student, Regular, Premier, and Elite. Points were credited per each one-way flight on Cyprus Airways. Economy class passengers gained 1 point per kilometer, and Business class passengers gained 1.5 points per kilometer.
Awards
Cyprus Airways was awarded the 'Commitment to Excellence in Europe' award by the European Foundation of Quality Management (EFQM) in 2007.
Cyprus Airways was also awarded the 'IATA Best In-flight Programming for a European airline' award.
Incidents and accidents
On 21 December 1961, Cyprus Airways Flight 226, a De Havilland Comet 4, owned and operated by British European Airways (BEA) on behalf of Cyprus Airways, crashed immediately after takeoff from Ankara. The probable cause was instrument failure. Seven of the 34 people on board survived. The four cabin crew were Cyprus Airways employees.
On 12 October 1967, Cyprus Airways Flight 284 broke up in midair on a flight between Athens and Nicosia, most likely as a result of the detonation of an explosive device. All 66 people on board died. Similar to the 1961 accident, the De Havilland Comet 4B aircraft was owned and operated by British European Airways (BEA), though cabin staff were Cyprus Airways employees.
References
External links
Official website)
Virtual tour of the Cyprus Airways Trident 5B-DAB stranded at Nicosia International Airport
Airlines established in 1947
Airlines disestablished in 2015
British Airways
Cypriot brands
+
Defunct airlines of Cyprus
Government-owned airlines
1947 establishments in Cyprus
2015 disestablishments in Cyprus
Companies based in Nicosia
|
```xml
import * as React from "react";
import Frame from "../components/Frame";
import Image from "../components/Img";
import { EmbedProps as Props } from ".";
function Diagrams({ matches, ...props }: Props) {
const { embed } = props;
const embedUrl = matches[0];
const params = new URL(embedUrl).searchParams;
const titlePrefix = embed.settings?.url ? "Draw.io" : "Diagrams.net";
const title = params.get("title")
? `${titlePrefix} (${params.get("title")})`
: titlePrefix;
return (
<Frame
{...props}
src={props.attrs.href}
icon={
<Image
src="/images/diagrams.png"
alt="Diagrams.net"
width={16}
height={16}
/>
}
canonicalUrl={props.attrs.href}
title={title}
border
/>
);
}
export default Diagrams;
```
|
Yusu Wang is a Chinese computer scientist and mathematician who works as a professor at the Halıcıoğlu Data Science Institute at the University of California, San Diego . Her research concerns computational geometry and computational topology, including results on discrete Laplace operators, curve simplification, and Fréchet distance.
Education and career
Wang graduated from Tsinghua University in 1998. She completed her Ph.D. in computer science at Duke University in 2004. Her dissertation, Geometric and Topological Methods in Protein Structure Analysis, was jointly supervised by Pankaj K. Agarwal and Herbert Edelsbrunner.
After postdoctoral research with Leonidas J. Guibas at Stanford University, Wang joined the faculty of the Ohio State University in 2005, and she was promoted to the rank of full professor there in 2017. She moved to her current position at the University of California, San Diego in 2020.
Service
Wang is on the editorial boards of the SIAM Journal on Computing and Journal of Computational Geometry.
With Gill Barequet, Wang was program co-chair of the 2019 Symposium on Computational Geometry.
References
External links
Home page
Year of birth missing (living people)
Living people
American computer scientists
21st-century American mathematicians
Chinese computer scientists
Chinese mathematicians
American women computer scientists
Women mathematicians
Researchers in geometric algorithms
Tsinghua University alumni
Duke University alumni
Ohio State University faculty
University of California, San Diego faculty
American women academics
21st-century American women
|
Jongno or Jong-ro () is a trunk road and one of the oldest major east–west thoroughfares in Seoul, South Korea. Jongno connects Gwanghwamun Plaza to Dongdaemun.
The area surrounding Jongno is a part of Downtown Seoul and one of the most prominent cultural, historical, and financial areas. Many important landmarks are located along its length, including the Bigak pavilion at Sejongno, the Bosingak belfry (hence the street's name), Tapgol Park (Pagoda Park), the Jongmyo royal ancestral shrine, and the Dongdaemun (Great East Gate). Seoul Subway Line 1 passes under Jongno. The western end of Jongno is serviced by Gwanghwamun Station (Seoul Subway Line 5), and Jongno 3-ga Station is serviced by Subway Lines 1, 3, and 5. Because of the multitude of shops, stores, and groceries along the area, the word "Jongno" is often used in the Korean language to express "Town Square."
Famous places in Jongno
Many of Korea's largest bookstores including the Kyobo Book Centre (near Sejongno), Youngpoong Bookstore, and Bandi & Luni's Bookstore (Jongno 1-ga) are located near Jongno.
Jongno Tower is a 33-story office building. Its top floor is equipped with a restaurant and bar which is famous for its view of Jongno and other areas of Seoul. The tower is located near Jonggak Station of Seoul Subway Line 1.
Insadong-gil, a street famous for its traditional attractions, including galleries, souvenir shops, and restaurants, is accessible directly from Jongno (Jongno 3-ga).
Cheonggyecheon flows just a block south of Jongno.
Sejong Center for the Performing Arts, one of the most famous multi-purpose theaters in Korea, lies near the intersection of Jongno and Sejongno.
The area around Jongno 3-ga Station is the origin of many famous movie theaters; Dansungsa (the oldest in Korea, established in 1907), The Piccadilly Cinema (established in 1958), Seoul Cinema (established in 1978).
Pimatgol is a well-known alley lying just north of Jongno 1, 2, 3-ga.
Dongdaemun, which is more properly known as Heunginjimun, is one of the four gates of old Seoul. It is located at the east end of Jongno.
Dongdaemun Market, one of the best-known wholesale and retail shopping places in Korea, surrounds the area near Jongno 5-ga Station, Dongdaemun Stadium and Dongdaemun History & Culture Park Station.
See also
Jongno district
Notes and References
Streets in Seoul
Tourist attractions in Seoul
Jongno District
|
```ruby
# For Keystone Engine. AUTO-GENERATED FILE, DO NOT EDIT [keystone_const.rb]
module Keystone
KS_API_MAJOR = 0
KS_API_MINOR = 9
KS_VERSION_MAJOR = 0
KS_VERSION_MINOR = 9
KS_VERSION_EXTRA = 2
KS_ARCH_ARM = 1
KS_ARCH_ARM64 = 2
KS_ARCH_MIPS = 3
KS_ARCH_X86 = 4
KS_ARCH_PPC = 5
KS_ARCH_SPARC = 6
KS_ARCH_SYSTEMZ = 7
KS_ARCH_HEXAGON = 8
KS_ARCH_EVM = 9
KS_ARCH_RISCV = 10
KS_ARCH_MAX = 11
KS_MODE_LITTLE_ENDIAN = 0
KS_MODE_BIG_ENDIAN = 1073741824
KS_MODE_ARM = 1
KS_MODE_THUMB = 16
KS_MODE_V8 = 64
KS_MODE_MICRO = 16
KS_MODE_MIPS3 = 32
KS_MODE_MIPS32R6 = 64
KS_MODE_MIPS32 = 4
KS_MODE_MIPS64 = 8
KS_MODE_16 = 2
KS_MODE_32 = 4
KS_MODE_64 = 8
KS_MODE_PPC32 = 4
KS_MODE_PPC64 = 8
KS_MODE_QPX = 16
KS_MODE_RISCV32 = 4
KS_MODE_RISCV64 = 8
KS_MODE_SPARC32 = 4
KS_MODE_SPARC64 = 8
KS_MODE_V9 = 16
KS_ERR_ASM = 128
KS_ERR_ASM_ARCH = 512
KS_ERR_OK = 0
KS_ERR_NOMEM = 1
KS_ERR_ARCH = 2
KS_ERR_HANDLE = 3
KS_ERR_MODE = 4
KS_ERR_VERSION = 5
KS_ERR_OPT_INVALID = 6
KS_ERR_ASM_EXPR_TOKEN = 128
KS_ERR_ASM_DIRECTIVE_VALUE_RANGE = 129
KS_ERR_ASM_DIRECTIVE_ID = 130
KS_ERR_ASM_DIRECTIVE_TOKEN = 131
KS_ERR_ASM_DIRECTIVE_STR = 132
KS_ERR_ASM_DIRECTIVE_COMMA = 133
KS_ERR_ASM_DIRECTIVE_RELOC_NAME = 134
KS_ERR_ASM_DIRECTIVE_RELOC_TOKEN = 135
KS_ERR_ASM_DIRECTIVE_FPOINT = 136
KS_ERR_ASM_DIRECTIVE_UNKNOWN = 137
KS_ERR_ASM_DIRECTIVE_EQU = 138
KS_ERR_ASM_DIRECTIVE_INVALID = 139
KS_ERR_ASM_VARIANT_INVALID = 140
KS_ERR_ASM_EXPR_BRACKET = 141
KS_ERR_ASM_SYMBOL_MODIFIER = 142
KS_ERR_ASM_SYMBOL_REDEFINED = 143
KS_ERR_ASM_SYMBOL_MISSING = 144
KS_ERR_ASM_RPAREN = 145
KS_ERR_ASM_STAT_TOKEN = 146
KS_ERR_ASM_UNSUPPORTED = 147
KS_ERR_ASM_MACRO_TOKEN = 148
KS_ERR_ASM_MACRO_PAREN = 149
KS_ERR_ASM_MACRO_EQU = 150
KS_ERR_ASM_MACRO_ARGS = 151
KS_ERR_ASM_MACRO_LEVELS_EXCEED = 152
KS_ERR_ASM_MACRO_STR = 153
KS_ERR_ASM_MACRO_INVALID = 154
KS_ERR_ASM_ESC_BACKSLASH = 155
KS_ERR_ASM_ESC_OCTAL = 156
KS_ERR_ASM_ESC_SEQUENCE = 157
KS_ERR_ASM_ESC_STR = 158
KS_ERR_ASM_TOKEN_INVALID = 159
KS_ERR_ASM_INSN_UNSUPPORTED = 160
KS_ERR_ASM_FIXUP_INVALID = 161
KS_ERR_ASM_LABEL_INVALID = 162
KS_ERR_ASM_FRAGMENT_INVALID = 163
KS_ERR_ASM_INVALIDOPERAND = 512
KS_ERR_ASM_MISSINGFEATURE = 513
KS_ERR_ASM_MNEMONICFAIL = 514
KS_OPT_SYNTAX = 1
KS_OPT_SYM_RESOLVER = 2
KS_OPT_SYNTAX_INTEL = 1
KS_OPT_SYNTAX_ATT = 2
KS_OPT_SYNTAX_NASM = 4
KS_OPT_SYNTAX_MASM = 8
KS_OPT_SYNTAX_GAS = 16
KS_OPT_SYNTAX_RADIX16 = 32
end
```
|
Trishna may refer to:
Taṇhā, the Buddhist concept of thirst or desire
Trishna (Vedic thought), the Vedic concept of thirst or desire
Trishna (1978 film), a drama directed and produced by Sippy Films in India
Thrishna, a 1981 Indian Malayalam-language film by I. V. Sasi
Trishna (2009 film), an Indian romance film directed by Pritam Jalan
Trishna (2011 film), a film adaptation of Tess of the d'Urbervilles and directed by Michael Winterbottom
Trishna (TV show), a romantic Indian TV show on Doordarshan
Trishna (yacht), a yacht belonging to the Corps of Engineers of the Indian Army
Krishna and Trishna, Bangladeshi conjoined twins
|
First Lieutenant Albert E. Fernald (May 13, 1838 – December 3, 1908) was an American soldier who fought in the American Civil War. Fernald received the country's highest award for bravery during combat, the Medal of Honor, for his action during the Battle of Five Forks in Virginia on 1 April 1865. He was honored with the award on 10 May 1865.
Biography
Fernald was born in Winterport, Maine, on 13 May 1838. He enlisted into the 20th Maine Infantry. He died on 3 December 1908 and his remains are interred at the Oak Hill Cemetery in Maine.
Medal of Honor citation
See also
List of American Civil War Medal of Honor recipients: A–F
References
1838 births
1908 deaths
People of Maine in the American Civil War
Union Army officers
United States Army Medal of Honor recipients
American Civil War recipients of the Medal of Honor
People from Winterport, Maine
|
"Nowhere girls" or "Mei Nu" () is a neologism coined to describe women who have no money, no job, no education, no prospects, no looks, no friends and no sophistication. The pinyin and pronunciation of "nowhere girls" is the same as that of "beautiful girls" in Putonghua.
The term is used to characterise those women who refuse to conform to male expectations and are therefore thought to be unattractive by men, and has strong pejorative connotations. A calque of a South Korean term, it spread to Hong Kong via China, and became popularised through its use in a reality show called Nowhere Girls, which was broadcast by Television Broadcasts Limited. This show has aroused much public discussion on this topic.
Description
In the TV programme Nowhere Girls, women are called "nowhere girls" because they are lazy, selfish, short-tempered, rude to others, unfashionable and self-deluded.
Characteristics
Don't conform to traditional expectations of beauty
Unemployed or have low income
Lack social competence
Tend to escape reality
Self-centered, deny any problems of themselves
Emotional or short-tempered
Dependent
Causes
Family
As nowhere girls experience distinct family affairs, leaving them psychologically hurt. Moreover, Hong Kong has low birth rates from time to time, leading to single-child families. They become the treasure of their parents. They are pampered and spoiled, which results in weakened coping abilities. In addition, children nowadays engage in less communication with their parents who are always out for work, and thus children receive less parental mental support.
Societal
Nowhere girls do not conform to traditional notions of beauty. In addition, they are self-centered and short-tempered. It is difficult for them to engage in the society with appropriate communication and to cooperate with others. As they are spoiled by their parents, they lack essential skills like problem-solving skills. Therefore, they do not appeal to employers and thus cannot find a job, while they insist that it is a social discrimination.
Effects
Low self-esteem
Nowhere girls become less confident and inferior in front of their friends and families because they are not appreciated. For instance, the participants in the Nowhere Girls show cried frequently in front of the camera. They were being teased in the cyber world. in which their background informations were being disclosed in the public. In severe cases, they may suffer from depression or psychological illnesses.
Socially withdrawn
Nowhere girls are less willing to engage in social activities. They prefer being alone instead of participating in social gatherings to avoid any embarrassment. They have low sense of connection with their social circles. Moreover, they may undergo difficulties in meeting new friends as they are not being recognised.
High family pressure
Most of the nowhere girls are either single or unmarried. Their parents will be anxious about their marital status as Chinese people values marriage. They will be pressurised to find their partners as soon as possible. This brings them great pressure in fulfilling their parents' expectations, and also deteriorates their family relationships.
Pessimistic attitude towards life
Nowhere girls hold negative attitudes towards their futures. They perceive their life as unfortunate. Therefore, they always think pessimistically since they consider their lives as hopeless. Lacking of security in their family will further result in their inclination into pessimism.
Media
TV programme
Nowhere Girls () is a reality show produced by Television Broadcasts Limited. It was broadcast in August 2014 and there are 20 episodes in total. The show focuses on seven women who are described as "have nots" and each of them is said to represent one of "seven deadly sins", including laziness, selfishness, ugliness and being a recent mainland immigrant etc. This programme stirred up much controversy since it discriminated against so-called "Mei Nu" and brought out wrong messages – "makeovers, working with fitness trainers and life coaches can lead to better lives" to the audience.
There were also suspicions that seven women got paid to act and some incidents were staged. Moreover, the show hurt the professional image of psychologists in Hong Kong because Wong Hoi-man, who is a clinical psychologist and the guest counsellor of Nowhere Girls, handled cases in improper ways. It led to misunderstandings towards therapeutic techniques of qualified psychologists.
See also
Chinese ideals of female beauty
References
Culture-bound syndromes
Culture of Hong Kong
Taiwanese culture
Chinese culture
South Korean culture
Pejorative terms for women
Stereotypes of women
Women in Hong Kong
Women in China
|
The history of Christianity in Romania began within the Roman province of Lower Moesia, where many Christians were martyred at the end of the 3rd century. Evidence of Christian communities has been found in the territory of modern Romania at over a hundred archaeological sites from the 3rd and 4th centuries. However, sources from the 7th and 10th centuries are so scarce that Christianity seems to have diminished during this period.
The vast majority of Romanians are adherent to the Eastern Orthodox Church, while most other populations that speak Romance languages follow the Catholic Church. The basic Christian terminology in Romanian is of Latin origin, though the Romanians, referred to as Vlachs in medieval sources, borrowed numerous South Slavic terms due to the adoption of the liturgy officiated in Old Church Slavonic. The earliest Romanian translations of religious texts appeared in the 15th century, and the first complete translation of the Bible was published in 1688.
The oldest proof that an Orthodox church hierarchy existed among the Romanians north of the river Danube is a papal bull of 1234. In the territories east and south of the Carpathian Mountains, two metropolitan sees subordinate to the Ecumenical Patriarch of Constantinople were set up after the foundation of two principalities, Wallachia and Moldavia in the 14th century. The growth of monasticism in Moldavia provided a historical link between the 14th-century Hesychast revival and the modern development of the monastic tradition in Eastern Europe. Orthodoxy was for centuries only tolerated in the regions west of the Carpathians where Roman Catholic dioceses were established within the Kingdom of Hungary in the 11th century. In these territories, transformed into the Principality of Transylvania in the 16th century, four "received religions" – Catholicism, Calvinism, Lutheranism, and Unitarianism – were granted a privileged status. After the principality was annexed by the Habsburg Empire, a part of the local Orthodox clergy declared the union with Rome in 1698.
The autocephaly of the Romanian Orthodox Church was canonically recognized in 1885, years after the union of Wallachia and Moldavia into Romania. The Orthodox Church and the Romanian Church United with Rome were declared national churches in 1923. The Communist authorities abolished the latter, and the former was subordinated to the government in 1948. The Uniate Church was reestablished when the Communist regime collapsed in 1989. Now the Constitution of Romania emphasizes churches' autonomy from the state.
Pre-Christian religions
The religion of the Getae, an Indo-European people inhabiting the Lower Danube region in antiquity, was characterized by a belief in the immortality of the soul. Another major feature of this religion was the cult of Zalmoxis; followers of Zalmoxis communicated with him by human sacrifice.
Modern Dobruja – the territory between the river Danube and the Black Sea – was annexed to the Roman province of Moesia in 46 AD. Cults of Greek gods remained prevalent in this area, even after the conquest. Modern Banat, Oltenia, and Transylvania were transformed into the Roman province of "Dacia Traiana" in 106. Due to massive colonization, cults originating in the empire's other provinces entered Dacia. Around 73% of all epigraphic monuments at this time were dedicated to Graeco-Roman gods.
The province of "Dacia Traiana" was dissolved in the 270s. Modern Dobruja became a separate province under the name of Scythia Minor in 297.
Origin of the Romanians' Christianity
The oldest proof that an Orthodox church hierarchy existed among the Romanians north of the river Danube is a papal bull of 1234. In the territories east and south of the Carpathian Mountains, two metropolitan sees subordinate to the Ecumenical Patriarch of Constantinople were set up after the foundation of two principalities, Wallachia and Moldavia in the 14th century. The growth of monasticism in Moldavia provided a historical link between the 14th-century Hesychast revival and the modern development of the monastic tradition in Eastern Europe. Orthodoxy was for centuries only tolerated in the regions west of the Carpathians where Roman Catholic dioceses were established within the Kingdom of Hungary in the 11th century. In these territories, transformed into the Principality of Transylvania in the 16th century, four "received religions" – Calvinism, Catholicism, Lutheranism, and Unitarianism – were granted a privileged status. After the principality was annexed by the Habsburg Empire, a part of the local Orthodox clergy declared the union with Rome in 1698.
The core religious vocabulary of the Romanian language originated from Latin. Christian words that have been preserved from Latin include a boteza ("to baptize"), Paște ("Easter"), preot ("priest"), and cruce ("cross"). Some words, such as biserică ("church", from basilica) and Dumnezeu ("God", from Domine Deus), are independent of their synonyms in other Romance languages.
The exclusive presence in Romanian language of Latin vocabulary for concepts of Christian faith may indicate the antiquity of Daco-Roman Christianity; some examples are:
The same is true for the Christian denominations of the main Christian holidays: Crăciun ("Christmas") (from or rather from ) and Paște ("Easter") (from ); Several archaic or popular saint names, sometimes found as elements in place names, also seem to derive from Latin: , and . Today, sfânt, of Slavic origin, is the usual way to refer to saint.
The Romanian language also adopted many Slavic religious terms. For example, words like duh ("soul, spirit"), iad ("hell"), rai ("paradise"), grijanie ("Holy Communion"), popă ("priest"), slujbă ("church service") and taină ("mystery, sacrament") are of South Slavic origin. Even some terms of Greek and Latin origin, such as călugar ("monk") and Rusalii ("Whitsuntide"), entered Romanian through Slavic. Several terms relating to church hierarchy, such as episcop ("bishop"), arhiepiscop ("archbishop"), ierarh ("hierarch"), mitropolit ("archbishop"), came from Medieval or Byzantine Greek, sometimes partly through a South Slavic intermediate A smaller number of religious terms were borrowed from Hungarian, for instance mântuire (salvation) and pildă (parable).
Several theories exist regarding the origin of Christianity in Romania. Those who think that the Romanians descended from the inhabitants of "Dacia Traiana" suggest that the spread of Christianity coincided with the formation of the Romanian nation. Their ancestors' Romanization and Christianization, a direct result of the contact between the native Dacians and the Roman colonists, lasted for several centuries. According to historian Ioan-Aurel Pop, Romanians were the first to adopt Christianity among the peoples who now inhabit the territories bordering Romania. They adopted Slavonic liturgy when it was introduced in the neighboring First Bulgarian Empire and Kievan Rus' in the 9th and 10th centuries. According to a concurring scholarly theory, the Romanians' ancestors turned to Christianity in the provinces to the south of the Danube (in present-day Bulgaria and Serbia) after it was legalized throughout the Roman Empire in 313. They adopted the Slavonic liturgy during the First Bulgarian Empire before their migration to the territory of modern Romania began in the 11th or 12th century.
Roman times
Christian communities in Romania date at least from the 3rd century. According to an oral history first recorded by Hippolytus of Rome in the early 3rd century, Jesus Christ's teachings were first propagated in "Scythia" by Saint Andrew. If "Scythia" refers to Scythia Minor, and not to the Crimea as has been claimed by the Russian Orthodox Church, Christianity in Romania can be considered of apostolic origin.
The existence of Christian communities in Dacia Traiana is disputed. Some Christian objects found there are dated from the 3rd century, preceding the Roman withdrawal from the region. Vessels with the sign of the cross, fish, grape stalks, and other Christian symbols were discovered in Ulpia Traiana, Porolissum, Potaissa, Apulum, Romula, and Gherla, among other settlements. A gem representing the Good Shepherd was found at Potaissa. On a funerary altar in Napoca the sign of the cross was carved inside the letter "O" of the original pagan inscription of the monument, and pagan monuments that were later Christianized were also found at Ampelum and Potaissa. A turquoise and gold ring with the inscription "" ("I am Jupiter's scourge against the dissolute Christians") was also found and may be related to the Christian persecutions during the 3rd century.
In Scythia Minor, a large number of Christians were martyred during the Diocletianic Persecution at the turn of the 3rd and 4th centuries. Four martyrs' relics were discovered in a crypt at Niculițel, with their names written in Greek on the crypt's inner wall. Thirty-five basilicas built between the 4th and 6th centuries have been discovered in the main towns of the province. The earliest basilica, built north of the Lower Danube, was erected at Sucidava (now Celei), in one of the Roman forts rebuilt under Justinian I (527–565). Burial chambers were built in Callatis (now Mangalia), Capidava, and other towns of Scythia Minor during the 6th century. The walls were painted with quotes from Psalms.
Clerics from Scythia Minor were involved in the theological controversies debated at the first four Ecumenical Councils. Saint Bretanion defended the Orthodox faith against Arianism in the 360s. The metropolitans of the province who supervised fourteen bishops by the end of the 5th century had their See in Tomis (modernly Constanța). The last metropolitan was mentioned in the 6th century, before Scythia Minor fell to the Avars and Sclavenes who destroyed the forts on the Lower Danube. John Cassian (360–435), Dionysius Exiguus (470–574) and Joannes Maxentius (leader of the so-called Scythian Monks) lived in Scythia Minor and contributed to its Christianization.
Early Middle Ages
East Roman Empire period
Most Christian objects from the 4th to 6th centuries found in the former province of Dacia Traiana were imported from the Roman Empire. The idea that public edifices were transformed into Christian cult sites at Slăveni and Porolissum has not been unanimously accepted by archaeologists. One of the first Christian objects found in Transylvania was a pierced bronze inscription discovered at Biertan. A few 4th century graves in the Sântana de Mureș–Chernyakhov necropolises was arranged in a Christian orientation. Clay lamps bearing depictions of crosses from the 5th and 6th centuries were also found here.
Dacia Traiana was dominated by "Taifali, Victuali, and Tervingi" around 350. Christian teachings among the Tervingi who formed the Western Goths started in the 3rd century. For instance, the ancestors of Ulfilas, who was consecrated "bishop of the Christians in the Getic land" in 341, had been captured in Capadocia (Turkey) around 250. During the first Gothic persecution of Christians in 348, Ulfilas was expelled to Moesia, where he continued to preach Greek, Latin, and Gothic languages. During the second persecution between 369 and 372, many believers were martyred, including Sabbas the Goth. The remains of twenty-six Gothic martyrs were transferred to the Roman Empire after the invasion of the Huns in 376.
Following the collapse of the Hunnic Empire in 454, the Gepids "ruled as victors over the extent of all Dacia". A gold ring from a 5th-century grave at Apahida is ornamented with crosses. Another ring from the grave bears the inscription "", probably in reference to Omharus, one of the known Gepid kings. The Gepidic kingdom was annihilated in 567–568 by the Avars.
The presence of Christians among the "barbarians" has been well documented. Theophylact Simocatta wrote of a Gepid who "had once long before been of the Christian religion". The author of the Strategikon documented Romans among the Sclavenes, and some of those Romans may have been Christians as well. The presence and proselytism of these Christians does not go so far as to explain how artifacts with Christian symbolism appeared on sites to the south and east of the Carpathians in the 560s. Such artifacts have been found at Botoșana and Dulceanca. Casting molds for pectoral crosses were found in the space around Eastern and Southern Carpathian mountains, starting with the 6th century.
Outer-Carpathian regions and the Balkans
Burial assemblages found in 8th-century cemeteries to the south and east of the Carpathians, for instance at Castelu, prove that local communities practiced cremation The idea that local Christians incorporating pre-Christian practices can also be assumed among those who cremated their dead is a matter of debate among historians. Cremation was replaced by inhumation by the beginning of the 11th century.
For the period from the 9th to 11th centuries, in the regions from the East of Carpathians there are known more than 52 discoveries of Christian origin (moulds, brackets, pendants, groundsels, pottery with Christian signs, rings with Christian signs), many of them locally made; some of these discoveries and the content and the orientation of graves show that local people practised the Christian burial ceremony before the Christianization of Bulgars and Slavs.
The territories between the Lower Danube and the Carpathians were incorporated into the First Bulgarian Empire by the first half of the 9th century. Boris I (852–889) was the first Bulgarian ruler to accept Christianity, in 863. By that time differences between the Eastern and the Western branches of Christianity had grown significantly. Boris I allowed the members of the Eastern Orthodox clergy to enter his country in 864, and the Bulgarian Orthodox Church adopted the Bulgarian alphabet in 893. An inscription in Mircea Vodă from 943 is the earliest example of the use of Cyrillic script in Romania.
The First Bulgarian Empire was conquered by the Byzantines under Basil II (976–1025). He soon revived the Metropolitan See of Scythia Minor at Constanța, but this put Christian Bulgarians under the jurisdiction of the archbishop of Ohrid. The Metropolitan See of Moesia was reestablished in Dristra (now Silistra, Bulgaria) in the 1040s when a mission of mass evangelization was dispatched among the Pechenegs who had settled in the Byzantine Empire. The Metropolitan See of Dristra was taken over by the bishop of Vicina in the 1260s.
The Vlachs living in Boeotia, Greece were described as false Christians by Benjamin of Tudela in 1165. However, the brothers Peter and Asen built a church in order to gather Bulgarian and Vlach prophets to announce that St Demetrius of Thessaloniki had abandoned their enemies, while arranging their rebellion against the Byzantine Empire. The Bulgarians and the Vlachs revolted and created the Second Bulgarian Empire. The head of the Bulgarian Orthodox Church was elevated to the rank of "Primate of the Bulgarians and the Vlachs" in 1204.
Catholic missionaries among the Cumans, who had controlled the territories north of the Lower Danube and east of the Carpathians from the 1070s, were first conducted by the Teutonic Knights, and later by the Dominicans, after 1225. A new Catholic diocese was set up in the region in 1228 by Archbishop Robert of Esztergom, the papal legate for "Cumania and the Brodnik lands". A letter written by Pope Gregory IX revealed that many of the inhabitants of this diocese were Orthodox Romanians, who also converted Hungarian and Saxon colonists to their faith.
Intra-Carpathian regions
Christian objects disappeared in Transylvania after the 7th century. Most local cemeteries had cremation graves by this point, but inhumation graves with west–east orientation from the late 9th or early 10th century were found at Ciumbrud and Orăștie. The territory was invaded by the Hungarians around 896.
The second-in-command of the Hungarian tribal federation, known as the gyula, converted to Christianity in Constantinople around 952. The gyula was accompanied back to Hungary by the Greek Hierotheos, who was the bishop of Tourkia (Hungary) appointed by the Ecumenical Patriarch. Pectoral crosses of Byzantine origin from this period have been found at the confluence of the Mureș and Tisa Rivers. A bronze cross from Alba Iulia, and a Byzantine pectoral cross from Dăbâca from the 10th century have been found in Transylvania. Additionally, a Greek monastery was founded at Cenad by a chieftain named Achtum who was baptized according to the Greek rite around 1002.
Gyula's territory was incorporated with Achtum's territory into the Kingdom of Hungary under Stephen I, who was baptized according to the Latin rite. Stephen I introduced the tithe, a church tax assessed on agricultural products. Roman Catholic Archdiocese of Alba Iulia, Roman Catholic Diocese of Szeged–Csanád, and Roman Catholic Diocese of Oradea Mare were the first three Roman Catholic dioceses in Romania and all became suffragans of the archbishop of Kalocsa in Hungary. The provostship of Sibiu was transferred, upon the local Saxons's request, under the jurisdiction of the archbishop of Esztergom (Hungary) in 1212.
Large cemeteries developed around churches after church officials insisted on churchyard burials. The first Benedictine monastery in Transylvania was founded at Cluj-Manăștur in the second half of the 11th century. New monasteries were established during the next few centuries in Almașu, Herina, Mănăstireni, and Meseș. When the Cistercian abbey at Cârța was founded in the early 13th century, its estates were created on land belonging to the Vlachs. The enmity between the Eastern and Western Churches also increased during the 11th century.
Middle Ages
Orthodox Church in the intra-Carpathian regions
Although the Council of Buda prohibited the Eastern schism from erecting churches in 1279, numerous Orthodox churches were built in the period starting in the late 13th century. These churches were mainly made of wood, though some landowners erected stone churches on their estates. Most of these churches were built on the plan of a Greek cross. Some churches also display elements of Romanesque or Gothic architecture. Many churches were painted with votive portraits illustrating the church founders.
Local Orthodox hierarchies were often under the jurisdiction of the Metropolitan Sees of Wallachia and Moldavia by the late 14th century. For instance, the Metropolitan of Wallachia also styled himself "Exarch of all Hungary and the borderlands" in 1401. Orthodox monasteries in Romania, including Șcheii Brașovului, were centers of Slavonic writing. The Bible was first translated into Romanian by monks in Maramureș during the 15th century.
In 1356, Pope Innocent VI streghtened a previous bull addressed to the prior of the Dominican Order of Hungary, where he was instructed to preach the crusade “against all the inhabitants of Transylvania, Bosnia and Slavonia, which are heretics” (contra omnes Transilvanos, Bosnenses et Sclavonie, qui heretici fuerint).
Treatment of Orthodox Christians worsened under Louis I of Hungary, who ordered the arrest of Eastern Orthodox priests in Cuvin and Caraș in 1366. He also decreed that only those who "loyally follow the faith of the Roman Church may keep and own properties" in Hațeg, Caransebeș, and Mehadia. However, conversion was infrequent in this period; the Franciscan Bartholomew of Alverna complained in 1379 that "some stupid and indifferent people" disapprove of the conversion of "the Slavs and Romanians". Both Romanians and Catholic landowners objected to this command. Romanian chapels and stone churches built on the estates of Catholic noblemen and bishops were frequently mentioned in documents from the late 14th century.
A special inquisitor sent against the Hussites by the pope also took forcible measures against "schismatics" in 1436. Following the union of the Roman Catholic and Orthodox Churches at the Council of Florence in 1439, the local Romanian Church was considered to be united with Rome. Those who opposed the Church union, such as John of Caffa, were imprisoned.
Although the monarchs only insisted on the conversion of the Romanians living in the southern borderlands, many Romanian noblemen converted to Catholicism in the 15th century. Transylvanian authorities made systematic efforts to convert Romanians to Calvinism in the second half of the 16th century, and the expulsion of priests who did not convert to the "true faith" was ordered in 1566. Orthodox hierarchy was only restored under Stephen Báthory with the appointment of the Moldavian monk, Eftimie, as Orthodox bishop in 1571.
Orthodox Church in Moldavia and Wallachia
An unknown Italian geographer wrongly described the "Romanians and the Vlachs" as pagans in the early 14th century. For instance, Basarab I (c. 1310–1352), the Romanian ruler who achieved the independence of Wallachia in the territories between the Carpathians and the Lower Danube, was mentioned as "schismatic" by a royal diploma of 1332, referring to the Orthodox Church. The Metropolitan See of Wallachia was established in 1359 when the Ecumenical Patriarch assigned Hyakinthos, the last metropolitan of Vicina, to lead the local Orthodox Church. Although a second Metropolitan See, with jurisdiction over Oltenia, was set up in Severin (now Drobeta-Turnu Severin) in 1370, there was again only one Metropolitan in the principality after around 1403. The local Church was reorganized under Radu IV the Great (1496–1508) by Patriarch Nephon II of Constantinople, the former Ecumenical Patriarch who founded two suffragan bishoprics.
A second principality, Moldavia, achieved its independence in the territories to the east of the Carpathians under Bogdan I (1359 – c. 1365), but it still remained under the jurisdiction of the Orthodox hierarch of Halych (Ukraine). Although the metropolitan of Halych consecrated two bishops for Moldavia in 1386, the Ecumenical Patriarch objected to this. The patriarch established a separate metropolitan see for Moldavia in 1394, but his appointee was refused by Stephen I of Moldavia (1394–1399). The conflict was solved when the patriarch recognized a member of the princely family as metropolitan in 1401. In Moldavia, two suffragan bishoprics in Roman, and Rădăuți were first recorded in 1408 and 1471.
From the second half of the 14th century, Romanian princes sponsored the monasteries of Mount Athos (Greece). First, the Koutloumousiou monastery received donations from Nicholas Alexander of Wallachia (1352–1364). In Wallachia, the monastery at Vodița was established in 1372 by the monk Nicodemus from Serbia, who had embraced monastic life at Chilandar on Mount Athos. Monks fleeing from the Ottomans founded the earliest monastery in Moldavia at Neamț in 1407. From the 15th century the four Eastern patriarchs and several monastic institutions in the Ottoman Empire also received landed properties and other sources of income, such as mills, in the two principalities.
Many monasteries, such as Cozia in Wallachia, and Bistrița in Moldavia, became important centers of Slavonic literature. The earliest local chronicles, such as the "Chronicle of Putna", were also written by monks. Religious books in Old Church Slavonic were printed in Târgoviște under the auspices of the monk Macaria from Montenegro after 1508. Wallachia in particular became a leading center of the Orthodox world, which was demonstrated by the consecration of the cathedral of Curtea de Argeș in 1517 in the presence of the Ecumenical Patriarch and the Protos of Mount Athos. The painted monasteries of Moldavia are still an important symbol of cultural heritage today.
The extensive lands owned by monasteries made the monasteries a significant political and economic force. Many of these monasteries also owned Romani and Tatar slaves. Monastic institutions enjoyed fiscal privileges, including an exemption from taxes, although 16th-century monarchs occasionally tried to seize monastic assets.
Wallachia and Moldavia maintained their autonomous status, though the princes were obliged to pay a yearly tax to the sultans starting during the 15th century. Dobruja was annexed in 1417 by the Ottoman Empire, and the Ottomans also occupied parts of southern Moldavia in 1484, and Proilavia (now Brăila) in 1540. These territories were under the jurisdiction of the metropolitans of Dristra and Proilavia for several centuries following the annexation.
Other denominations
The Diocese of Cumania was destroyed during the Mongol invasion of 1241–1242. After this, Catholic missions to the East were carried on by the Franciscans. For example, Pope Nicholas IV sent Franciscan missionaries to the "country of the Vlachs" in 1288. In the 14th and 15th centuries new Catholic dioceses were established in the territories to the east and south of the Carpathians, mainly due to the presence of Hungarian and Saxon colonists. Local Romanians also sent a complaint to the Holy See in 1374 demanding a Romanian-speaking bishop. Alexander the Good of Moldavia (1400–1432) also founded an Armenian bishopric in Suceava in 1401. In Moldavia, however, many Catholic believers were forced to convert to Orthodoxy under Ștefan VI Rareș (1551–1552) and Alexandru Lăpușneanu (1552–1561).
In the Kingdom of Hungary parish organization became fully developed in the 14th to 15th centuries. In the 1330s, according to a papal tithe-register, the average ratio of villages with Catholic parishes was around forty percent in the entire kingdom, but in the territory of modern Romania there was a Catholic church in 954 settlements out of 2100 and 2200 settlements. The institutional and economic power of the Catholic Church in Transylvania was systematically dismantled by the authorities in the second half of the 16th century. The extensive lands of the bishopric of Transylvania were confiscated in 1542. The Catholic Church soon became deprived of its own higher local hierarchy and subordinate to a state governed by Protestant monarchs and Estates. Some of the local noblemen, including a branch of the powerful Báthory family and many Székelys, remained Catholics.
Reformation
First the Hussite movement for religious reform began in Transylvania in the 1430s. Many of the Hussites moved to Moldavia, the only state in Europe outside Bohemia where they remained free of persecution.
The earliest evidence that Lutheran teachings "were known and followed" in Transylvania is a royal letter written to the town council of Sibiu in 1524. The Transylvanian Saxons' assembly decreed the adoption of the Lutheran creed by all the Saxon towns in 1544. Municipal authorities also tried to influence the ritual of the Orthodox services. A Romanian Catechism was published in 1543, and a Romanian translation of the four Gospels in 1560.
Calvinist preachers first became active in Oradea in the early 1550s. The Diet recognized the existence of two distinct Protestant churches in 1564 after the Saxon and Hungarian clergy had failed to agree on the contested points of theology, such as the nature of communion services. The government also exerted pressure on the Romanians in order to change their faith. The Diet of 1566 decreed that a Romanian Calvinist bishop, Gheorghe of Sîngeorgiu, be their sole religious leader.
A faction of Hungarian preachers raised doubts over the doctrine of the Trinity in the 1560s. In a decade Cluj became the center of the Unitarian movement. The four "received religions" was recognized in 1568 by the Diet of Turda which also gave ministers the right to teach according to their own understanding of Christianity. Although a ban on further religious innovation was enacted in 1572, many Székelys turned to Sabbatarianism in the 1580s.
The process of giving up pre-Reformation traditions was extremely slow in Transylvania. Although all or some of the images were eliminated in the churches, sacred vessels were kept. Protestant denominations also kept the strict observance of holidays and fasting periods.
Early Modern and Modern Times
Orthodox Church in Moldavia, Wallachia, and Romania
The use of Romanian in church service was first introduced in Wallachia under Matei Basarab (1632–1654), and in Moldavia under Vasile Lupu (1634–1652). During Vasile Lupu's reign a pan-Orthodox synod adopted the "Orthodox Confession of Faith" in Iași in 1642 in order to reject any Calvinist influence over Orthodox hierarchy. The first complete Romanian "Book of Prayer" was published in 1679 by Metropolitan Dosoftei of Moldavia (1670–1686). A team of scholars also completed the Romanian translation of the Bible in 1688.
The two principalities suffered the highest degree of Ottoman exploitation during the "Phanariot century" (1711–1821) when princes appointed by the sultans ruled in both of them. The second half of the 18th century, brought a spiritual renaissance, initiated by Paisius Velichkovsky. His influence led to a resurgence of Hesychastic prayer in the monasteries in Moldavia. In this period Romanian theological culture benefited from new translations from patristic literature. In the first decades of the 19th century theological seminaries were established in both principalities, such as in the Socola Monastery in 1803, and in Bucharest in 1836.
A new archbishopric subordinated to the Synod of the Russian Orthodox Church was created in Chișinău when the Russian Empire annexed Bessarabia in 1812. The Russian authorities soon forbade its archbishop from having any connections with the Orthodox Church in the Romanian principalities.
Romanian society embarked upon a rapid development following the reinstallation of native princes in 1821. For instance, the Romani slaves owned by the monasteries were freed in Moldavia in 1844, and in Wallachia in 1847. The two principalities were united under Alexandru Ioan Cuza (1859–1866), and the new state adopted the name of Romania in 1862. In his reign, the estates of the monasteries were nationalized. He also endorsed the use of Romanian in the liturgy, and replaced the Cyrillic alphabet with the Romanian alphabet. In 1860, the first Faculty of Orthodox Theology was founded at the University of Iași.
The Orthodox churches of the former principalities, the Metropolitan of Ungro-Wallachia and the Metropolitan of Moldavia, merged to form the Romanian Orthodox Church. In 1864, the Romanian Orthodox Church was proclaimed independent, but the Ecumenical Patriarch pronounced the new ecclesiastic regime contrary to the holy canons. Henceforth all ecclesiastic appointments and decisions were subject to state approval. The Metropolitan of Wallachia, who received the title of Primate Metropolitan in 1865, became the head of the General Synod of the Romanian Orthodox Church. The 1866 Constitution of Romania recognized the Orthodox Church as the dominant religion in the kingdom. A law passed in 1872 declared the church to be "autocephalous". After a long period of negotiations with the Patriarchate of Constantinople, the latter finally recognized the Metropolis of Romania in 1885.
Following the Romanian War of Independence, Dobruja was awarded to Romania in 1878. At that time the majority of Dobruja's population was Muslim, but a massive colonization effort soon began. The region had also been inhabited from the late 17th century by a group of Russian Old Believers called Lipovans.
The Great Powers recognized Romania's independence in 1880, after Romania's constitution was modified to allow the naturalization of non-Christians. In order to solemnize Romania's independence, in 1882 the Orthodox hierarchy performed the ceremony of blessing the holy oil, a privilege that had thereto been reserved for the ecumenical patriarchs. The new conflict with the patriarch delayed the canonical recognition of the autocephaly of the Romanian Orthodox Church for three years, until 1885.
Orthodox Church in Transylvania and the Habsburg Empire
The 16th-century Calvinist princes of Transylvania insisted on the Orthodox clergy's unconditional subordination to the Calvinist superintendents. For instance, when an Orthodox synod adopted measures for regulation of church life Gabriel Bethlen (1613–1630) removed the local metropolitan. By forcing the use of Romanian instead of Old Church Slavonic in the liturgy, the authorities also contributed to the development of the Romanians' national consciousness. Local Orthodox believers remained without their own religious leader after the integration of Transylvania into the Habsburg Empire, when a synod led by the metropolitan declared the union with Rome in 1698.
The first movement for the reestablishment of the Orthodox Church was initiated in 1744 by Visarion Sarai, a Serbian monk. The monk Sofronie organized Romanian peasants to demand a Serbian Orthodox bishop in 1759–1760. In 1761 the government consented to the establishment of an Orthodox diocese in Sibiu under the jurisdiction of the Serbian Metropolitan of Sremski Karlovci. The Serbian Metropolitan was also granted authority, in 1781, over the diocese of Cernăuți (now Chernivtsi, Ukraine) in Bukovina that had been annexed from Moldavia by the Habsburg Empire.
In 1848 Andrei Șaguna became the bishop of Sibiu and worked to free the local Orthodox Church from the control of the Serbian Metropolitan. He succeeded in 1864, when a separate Orthodox Church with its Metropolitan See in Sibiu was established with the consent of the government. In the second half of the 19th century, the local Romanian Orthodox Church supervised the activity of four high schools, and over 2,700 elementary schools. The Orthodox Church in Bukovina also became independent of the Serbian Metropolitan in 1873. A Faculty of Orthodox Theology was founded in the University of Cernăuți in 1875. However, many Romanian priests were deported or imprisoned for propagating the union of the lands inhabited by Romanians after Romania declared war on Austria–Hungary in 1916.
Romanian Church united with Rome
After the Principality of Transylvania was annexed by the Habsburg Empire, the new Catholic rulers tried to attract the Romanians' support in order to strengthen their control over the principality governed by predominantly Protestant Estates. For the Romanians, the Church Union proposed by the imperial court nurtured the hope that the central government would assist them in their conflicts with local authorities.
The union of the local Romanian Orthodox Church with Rome was declared in Alba Iulia, after years of negotiations, in 1698 by Metropolitan Atanasie Anghel and thirty-eight archpriests. This union was based on the four points adopted by the Council of Florence, including the recognition of papal primacy. Atanasie Anghel lost his title of metropolitan and was re-ordained as a bishop subordinated to the archbishop of Esztergom in 1701.
The Orthodox world considered the union with Rome as apostasy. Metropolitan Theodosie of Wallachia referred to Atanasie Anghel as "the new Judas". Since many of the local Romanians opposed the Church union, it also created discord among them.
Uniate Romanians assumed a leading role in the struggle for the Romanians' political emancipation in Transylvania for the next century. Bishop Inocențiu Micu-Klein demanded in dozens of memoranda their recognition as the fourth "political nation" in the province. The Uniate bishopric in Transylvania was raised to the rank of a Metropolitan See and became independent of the archbishop of Esztergom in 1855.
Other denominations
Calvinism was popular in Transylvania during the 17th century. Over sixty Unitarian ministers were expelled from their parishes in the Székely Land in the 1620s due to the influence of Calvinist Church leaders. Although Transylanian Diets also enacted anti-Sabbatarian decrees, Sabbatarian communities survived in some Székely villages, such as Bezid.
The Saxon communities' religious life was characterized by both differentiation from Calvinism, and by an increased number of worship services. Traditional Lutheranism, due to its concern for individual spiritual needs, always remained more popular than Crypto-Calvinism. The assets of the local Catholic Church were administered by the "Catholic Estates", a public body consisting of both laymen and priests. A report on church visitations conducted around 1638 revealed that there were numerous Catholic villages without clergymen in the Székely Land.
The Principality of Transylvania, following its integration into the Habsburg Empire, was administered according to the principles established by the Leopoldine Diploma of 1690, which confirmed the privileged status of the four "received religions". In practice the new regime gave preference to the Roman Catholic Church. Between 1711 and 1750, the apogee of the Counter-Reformation, the government ensured that Catholics would get preference in appointments to high offices. The preeminent status of the Roman Catholic Church was not weakened under Joseph II (1780–1790), despite his issuance of the 1781 Edict of Tolerance. Catholics who wished to convert to any of the other three "received religions" were still required to undergo an instruction. The equal status of the Churches was not declared until the union of Transylvania with the Kingdom of Hungary in 1868.
In the Kingdom of Romania, a new Roman Catholic archbishopric was organized in 1883 with its See in Bucharest. Among the new Protestant movements, the first Baptist congregation was formed in 1856, and the Seventh-day Adventists were first introduced in Pitești in 1870.
Greater Romania
Following World War I, ethnic Romanians in Banat, Bessarabia, Bukovina and Transylvania voted for the union with the Kingdom of Romania. The new borders were recognized by international treaties in 1919–1920. Thus, a Romania that had thereto been a relatively homogeneous state now included a mixed religious and ethnic population. According to the 1930 census, 72 percent of its citizens were Orthodox, 7.9 percent Greek Catholic, 6.8 percent Lutheran, 3.9 percent Roman Catholic, and 2 percent Reformed.
The constitution adopted in 1923 declared that "differences of religious beliefs and denominations" do not constitute "an impediment either to the acquisition of political rights or to the free exercise thereof". It also recognized two national churches by declaring the Romanian Orthodox Church as the dominant denomination and by according the Romanian Church united with Rome "priority over other denominations". The 1928 Law of Cults granted a fully recognized status to seven more denominations, among them the Roman Catholic, the Armenian, the Reformed, the Lutheran, and the Unitarian Churches.
All Orthodox hierarchs in the enlarged kingdom became members of the Holy Synod of the Romanian Orthodox Church in 1919. New Orthodox bishoprics were set up, for instance, in Oradea, Cluj, Hotin (now Khotyn, Ukraine), and Timișoara. The head of the church was raised to the rank of patriarch in 1925. Orthodox ecclesiastical art flourished in this period due to the erection of new Orthodox churches especially in the towns of Transylvania. The 1920s also witnessed the emergence of Orthodox revival movements, among them the "Lord's Army" founded in 1923 by Iosif Trifa. Conservative Orthodox groups who refused to use the Gregorian calendar adopted by the Romanian Orthodox Church in 1925 formed the separate Old Calendar Romanian Orthodox Church.
In this period, the preservation of ethnic minorities' cultural heritage became a primary responsibility of the traditional Protestant denominations. The Reformed Church became closely identified with a large segment of the local Hungarian community, and the Lutheran Church perceived itself as the bearer of Transylvanian Saxon culture. Among the new Protestant denominations, the Pentecostal movement was declared illegal in 1923. The intense hostility between the Baptist and Orthodox communities also culminated in the temporary closing of all Baptist churches in 1938.
Communist regime
According to the armistice signed between Romania and the Allied Powers in 1944, Romania lost Bessarabia and Northern Bukovina to the Soviet Union. Consequently, the Orthodox dioceses in these territories were subordinated to the patriarch of the Russian Orthodox Church. In Romania, the Communist Party used the same tactics as in other Eastern European countries. The Communist Party supported a coalition government, but in short time drove out all other parties from power.
The 1948 Law on Religious Denominations formally upheld freedom of religion, but ambiguous stipulations obliged both priests and believers to conform to the constitution, national security, public order, and accepted morality. For example, priests who voiced anti-communist attitudes could be deprived of their state-sponsored salaries. The new law acknowledged fourteen denominations, among them the Old Rite Christian, Baptist, Adventist, and Pentecostal churches, but the Romanian Church united with Rome was abolished.
Although the Orthodox church was completely subordinated to the state through the appointment of patriarchs sympathetic to the Communists, over 1,700 Orthodox priests of the 9,000 Orthodox priests in Romania were arrested between 1945 and 1964. The Orthodox theologian Dumitru Stăniloae whose three-volume Dogmatic Theology presents a synthesis of patristic and contemporary themes was imprisoned between 1958 and 1964. The first Romanian saints were also canonized between 1950 and 1955. Among them, the 17th-century Sava Brancovici was canonized for his relations with Russia.
Some other denominations met an even more tragic fate. For instance, four of the five arrested Uniate bishops died in prison. Religious dissident movements became especially active between 1975 and 1983. For instance, the Orthodox priest Gheorghe Calciu-Dumitreasa spent sixteen years in prison for involvement with the fascist Iron Guard and was later condemned to ten more because of his sermons on the relationship of atheism, faith, and Marxism. The crisis that led to the regime's fall in 1989 also started with the staunch resistance of the Reformed pastor László Tőkés, whom the authorities wanted to silence.
Romania since 1989
The Communist regime came to an abrupt end on 22 December 1989. The poet Mircea Dinescu, who was the first to speak on liberated Romanian television, began his statement with the words: "God has turned his face toward Romania once again". The new constitution of Romania, adopted in 1992, guarantees the freedom of thought, opinion, and religious beliefs when manifested in a spirit of tolerance and mutual respect. Eighteen groups are currently recognized as religious denominations in the country. Over 350 other religious associations has also been registered, but they do not enjoy the right to build houses of worship or to perform rites of baptism, marriage, or burial.
Since the fall of Communism, about fourteen new Orthodox theology faculties and seminaries have opened, Orthodox monasteries have been reopened, and even new monasteries have been founded, for example, in Recea. The Holy Synod has canonized new saints, among them Stephen the Great of Moldavia (1457–1504), and declared the second Sunday after Pentecost the "Sunday of the Romanian Saints".
The Greek Catholic hierarchy was fully restored in 1990. The four Roman Catholic dioceses in Transylvania, composed primarily of Hungarian-speaking inhabitants, hoped to be united into a distinct ecclesiastical province, but only Alba Iulia was raised to an archbishopric and placed directly under the jurisdiction of the Holy See in 1992. After the exodus of the Transylvanian Saxons to Germany, only 30,000 of the members of the German Lutheran Church remained in Romania by the end of 1991. According to the 2002 census, 86.7 percent of Romania's total population was Orthodox, 4.7 percent Roman Catholic, 3.2 percent Reformed, 1.5 percent Pentecostal, 0.9 percent Greek Catholic, and 0.6 percent Baptist.
Footnotes
References
Berend, Nora; Laszlovszky, József; Szakács, Béla Zsolt (2007). The kingdom of Hungary. In: Berend, Nora (2007); Christianization and the Rise of Christian Monarchy: Scandinavia, Central Europe and Rus’, c. 900–1200; Cambridge University Press; .
Binns, John (2002). An Introduction to the Christian Orthodox Churches. Cambridge University Press. .
Boia, Lucian (2001). History and Myth in Romanian Consciousness. Central European University Press. .
Crowe, David M. (2007). A History of the Gypsies of Eastern Europe and Russia. Palgrave Macmillan. .
Cunningham, Mary B. (1999). The Orthodox Church in Byzantium. In: Hastings, Adrian (1999); A World History of Christianity; Cassell; .
Curta, Florin (2005). Before Cyril and Methodius: Christianity and Barbarians beyond the Sixth- and Seventh-Century Danube Frontier. In: Curta, Florin (2005); East Central & Eastern Europe in the Early Middle Ages; The University of Michigan Press; .
Curta, Florin (2006). Southeastern Europe in the Middle Ages, 500–1250. Cambridge University Press. .
Dobre, Claudia Florentina (2009). Mendicants in Moldavia: Mission in an Orthodox Land. AUREL Verlag. .
Fiedler, Uwe (2008). Bulgars in the Lower Danube Region: A Survey of the Archaeological Evidence and of the State of Current Research. In: Curta, Florin; Kovalev, Roman (2008); The Other Europe in the Middle Ages: Avars, Bulgars, Khazars, and Cumans; Brill; .
Fine, John V. A., Jr. (1991). The Early Medieval Balkans: A Critical Survey from the Sixth to the Late Twelfth Century. The University of Michigan Press. .
Georgescu, Vlad (1991). The Romanians: A History. Ohio State University Press. .
Keul, István (2009). Early Modern Religious Communities in East-Central Europe: Ethnic Diversity, Denominational Plurality, and Corporative Politics in the Principality of Transylvania (1526–1691). Brill. .
Kitromilides, Paschalis M. (2006). The Legacy of the French Revolution: Orthodoxy and Nationalism. In: Angold, Michael (2006); The Cambridge History of Christianity: Eastern Christianity; Cambridge University Press; .
Kristó, Gyula (2003). Early Transylvania (895–1324). Lucidus Kiadó. .
MacKendrick, Paul (1975). The Dacian Stones Speak. The University of North Carolina Press. .
Madgearu, Alexandru (2004). "The Spreading of Christianity in the rural areas of post-Roman Dacia (4th–7th centuries)" in Archaeus (2004), VIII, pp. 41–59.
Madgearu, Alexandru (2005). The Romanians in the Anonymous Gesta Hungarorum: Truth and Fiction. Romanian Cultural Institute. .
Magocsi, Paul Robert (2002). Historical Atlas of Central Europe. University of Washington Press. .
Murdock, Graeme (2000). Calvinism on the Frontier, 1600–1660: International Calvinism and the Reformed Church in Hungary and Transylvania. Oxford University Press. .
Niculescu, Gheorghe Alexandru (2007). Archaeology and Nationalism in The History of the Romanians. In: Kohl, Philip L.; Kozelsky, Mara; Ben-Yehuda, Nachman (2007); Selective Remembrances: Archaeology in the Construction, Commemoration, and Consecration of National Pasts; The University of Chicago Press; .
Păcurariu, Mircea (2007). Romanian Christianity. In: Parry, Ken (2007); The Blackwell Companion to Eastern Christianity; Blackwell Publishing; .
Papadakis, Aristeides; Meyendorff, John (1994). The Christian East and the Rise of the Papacy: The Church 1071–1453 A.D. St. Vladimir's Seminary Press. .
Pop, Ioan-Aurel; Nägler, Thomas; Bărbulescu, Mihai; Dörner, Anton E.; Glodariu, Ioan; Pop, Grigor P.; Rotea, Mihai; Sălăgean, Tudor; Vasiliev, Valentin; Aldea, Bogdan; Proctor, Richard (2005). The History of Transylvania, Vol. I. (Until 1541). Romanian Cultural Institute. .
Pop, Ioan-Aurel; Bolovan, Ioan (2006). History of Romania: Compendium. Romanian Cultural Institute (Center for Transylvanian Studies). .
Pop, Ioan Aurel(1996) "Românii și maghiarii în secolele IX-XIV. Geneza statului medieval în Transilvania." Centrul de studii transilvane. Fundația culturală română, Cluj-Napoca.
Pop, Ioan-Aurel; Nägler, Thomas; Magyari, András; Andea, Susana; Costea, Ionuț; Dörner, Anton; Felezeu, Călin; Ghitta, Ovidiu; Kovács, András; Doru, Radoslav; Rüsz Fogarasi, Enikő; Szegedi, Edit (2009). The History of Transylvania, Vol. II. (From 1541 to 1711). Romanian Academy, Center for Transylvanian Studies. .
Pope, Earl A. (1992). Protestantism in Romania. In: Ramet, Sabrina Petra (1992); Protestantism and Politics in Eastern Europe and Russia: The Communist and Post-Communist Eras; Duke University Press; .
Pozsony, Ferenc (2002). Church Life in Moldavian Hungarian Communities. In: Diószegi, László (2002); Hungarian Csángós in Moldavia: Essays on the Past and Present of the Hungarian Csángós in Moldavia; Teleki László Foundation – Pro Minoritate Foundation; .
Schramm, Gottfried (1997). Ein Damm bricht. Die römische Donaugrenze und die Invasionen des 5.–7. Jahrhunderts in Lichte der Namen und Wörter (A Dam Breaks: The Roman Danube frontier and the Invasions of the 5th–7th Centuries in the Light of Names and Words). R. Oldenbourg Verlag. .
Sedlar, Jean W. (1994). East Central Europe in the Middle Ages, 1000–1500. University of Washington Press. .
Shepard, Jonathan (2006). The Byzantine Commonwealth 1000–1500. In: Angold, Michael (2006); The Cambridge History of Christianity: Eastern Christianity; Cambridge University Press; .
Spinei, Victor (2009). The Romanians and the Turkic Nomads North of the Danube Delta from the Tenth to the Mid-Thirteenth Century. Brill. .
Stephenson, Paul (2000). Byzantium’s Balkan Frontier: A Political Study of the Northern Balkans, 900–1204. Cambridge University Press. .
Stan, Lavinia; Turcescu, Lucian (2007). Religion and Politics in Post-Communist Romania. Oxford University Press. .
Teodor, Eugen S. (2005). The Shadow of a Frontier: The Wallachian Plain during the Justinian Age. In: Curta, Florin (2005); Borders, Barriers, and Ethnogenesis: Frontiers in Late Antiquity and the Middle Ages; Brepols Publishers; .
Todd, Malcolm (1992). The Early Germans. Blackwell Publishing. .
Treptow, Kurt W.; Bolovan, Ioan; Constantiniu, Florin; Michelson, Paul E.; Pop, Ioan-Aurel; Popa, Cristian; Popa, Marcel; Scurtu, Ioan; Vultur, Marcela; Watts, Larry L. (1997). A History of Romania. The Center for Romanian Studies. .
Treptow, Kurt W.; Popa, Marcel (1996). Historical Dictionary of Romania. The Scarecrow Press. .
Wolfram, Herwig (1988). History of the Goths. University of California Press. .
Zugravu, Nelu (1995–1996). "Cu privire la jurisdicția creștinilor nord-dunăreni în secolele II-VIII" in Pontica (1995–1996), XXVIII-XXIX, pp. 163–181.
Early Christian inscriptions
|
```xml
import React from 'react';
import { Seekbar } from '../..';
export default {
title: 'Components/Seekbar'
};
export const Basic = () => (
<div>
Seekbars filled to various levels.
<br /><br />
60%:
<Seekbar fill={60} />
<br />
70%:
<Seekbar fill={70} />
<br />
80%:
<Seekbar fill={80} />
<br />
30%:
<Seekbar fill={30} />
<br />
10%:
<Seekbar fill={10} />
<br />
</div>
);
export const Loading = () => (
<div>
Seekbar while loading a track.
<br/><br/>
<Seekbar isLoading />
</div>
);
export const WithSkippableSegments = () => <div style={{
display: 'flex',
flexFlow: 'column',
height: '100%'
}}>
<div style={{flex: '1 1 auto'}} />
<Seekbar
fill={75}
skipSegments={[{
startTime: 10,
endTime: 35
}, {
startTime: 50,
endTime: 60
}, {
startTime: 70,
endTime: 85
}]}
queue={{
queueItems: [{
streams: [{
duration: 100
}]
}],
currentSong: 0
}}
segmentPopupMessage='Non-music'
/>
</div>;
```
|
```swift
//
// OtherExampleViewController.swift
// HGCircularSlider
//
// Created by Hamza Ghazouani on 09/11/2016.
//
import UIKit
import HGCircularSlider
extension CALayer {
func borderUIColor() -> UIColor? {
return borderColor != nil ? UIColor(cgColor: borderColor!) : nil
}
func setBorderUIColor(_ color: UIColor) {
borderColor = color.cgColor
}
}
class OtherExampleViewController: UIViewController {
@IBOutlet weak var circularSlider: MidPointCircularSlider!
override func viewDidLoad() {
super.viewDidLoad()
circularSlider.minimumValue = 0.0
circularSlider.maximumValue = 10.0
circularSlider.distance = 1.0
circularSlider.midPointValue = 5.0
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
/*
// MARK: - Navigation
// In a storyboard-based application, you will often want to do a little preparation before navigation
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
// Get the new view controller using segue.destinationViewController.
// Pass the selected object to the new view controller.
}
*/
}
```
|
Avena fatua is a species of grass in the oat genus. It is known as the common wild oat. This oat is native to Eurasia but it has been introduced to most of the other temperate regions of the world. It is naturalized in some areas and considered a noxious weed in others.
A. fatua is a typical oat in appearance, a green grass with hollow, erect stems tall bearing nodding structures – panicles – of spikelets. The long dark green leaves are up to wide and rough due to small hairs. The seedlings are also hairy. The seed kernel is thinner, longer, darker and hairy when compared with the seed of the common cultivated oat (A. sativa). This species and other wild oats can become troublesome in prairie agriculture when it invades and lowers the quality of a field crop, or competes for resources with the crop plants. It takes very few wild oat plants to cause a significant reduction in the yield of a wheat or cultivated oat field.
References
External links
Jepson Manual Treatment
Calphotos Photo gallery, University of California
fatua
Flora of Asia
Flora of Europe
Plants described in 1753
Taxa named by Carl Linnaeus
|
Rison is a city in and the county seat of Cleveland County, Arkansas, United States. Its population was 1,344 at the 2010 U.S. census. It is included in the Pine Bluff, Arkansas Metropolitan Statistical Area. Rison is a bedroom community for people who work in Pine Bluff (in neighboring Jefferson County). The largest employers are the city and county governments, the Cleveland County School District, the Cleveland County Nursing Home. There are two banks, eight churches, and about forty-five businesses within the city limits. Among the local properties listed on the National Register of Historic Places are the Rison Cities Service Station and the Rison Texaco Service Station.
History
The Texas and St. Louis Railroad gave rise to Rison. The county seat of Dorsey (later Cleveland) County was originally at Toledo. When the railroad was routed through the county in 1882, Rison did not exist as a place name. Samuel Wesley Fordyce of Huntsville, Alabama, a former Union army officer, was authorized to determine the route of the railroad from Texarkana (Miller County) to Birds Point, Missouri. According to unsubstantiated legend, when the leading citizens of Toledo snubbed his plans to route the railroad through that community, he planned a route three miles north through land that later became the town of Rison.
Samuel W. Fordyce named the growing community in honor of William Richard Rison, his former partner in a banking venture in Alabama, who had fought on the opposite side of the Civil War from Samuel. The first home erected in the community that became Rison was built in 1880 by lawyer and farmer James M. McMurtrey. In 1883, the Southwest Improvement Association, a subsidiary of the railroad company, presented a parcel of land for use by the inhabitants of the area that became Rison. Rison was incorporated in 1890 with J. T. Renfrow as mayor. The name of the county was changed from Dorsey to Cleveland in 1885; the popularity of U.S. Senator Stephen Dorsey had waned, and President Grover Cleveland’s name was substituted. The state Supreme Court moved the county seat from Toledo to Rison in 1891 after a spirited battle among the leading contenders, Toledo, Kingsland, and Rison.
The railroad remained Rison’s point of reference for decades. “Rison on the Cotton Belt” was the affectionate way residents referred to their community. The commercial value of the railroad was felt from the beginning. The economy depended on the production of cotton, lumber, and, ultimately, a wide variety of wood products, including pulpwood, piling, pallets, broom handle squares, ammunition boxes, and U.S. Army pup tent poles.
The financial make-up of the community was divided for several decades into owners and sharecroppers. The emergence of the timber-related wood products business ultimately skewed that economic picture, with the corresponding rise of the merchant entrepreneurs also affecting it somewhat. Nevertheless, family fortunes were built on the owner/sharecropper system, and they influenced the financial and social structure of the town. Sharecropping was the prevailing structure of the primary business enterprise in the county until the land became depleted by failure to rotate crops adequately.
The Cleveland County Courthouse was built in 1911 after two contested elections. Two years later, the Phoenix Hotel was built and served as a popular gathering spot for the local community.
Three cotton gins operated in and around Rison. The largest and most efficient gin was owned by Ira E. Moore. That gin was built in 1933 to replace one owned by Moore that was built in 1926 and burned in 1933. The more modern and efficient all-electric gin built in 1933 was the first of its kind in the area.
Residents of Rison owned and operated a dozen or more sawmills. The largest lumber mills were the J. I. Porter Lumber Company and the Clio Lumber Company. The Clio mill was built in 1887 five miles north of Rison. According to a 1909 issue of Lumberman’s Magazine, the Clio mill owned several thousand acres of timberland and had 432 employees in the sawmill, 130 on the woods crew, and eighty operating the tramlines that transported the logs to the mill. Other mills that added significantly to the economy were the J. L. Sadler Lumber Company, the C. L. Garner & Sons Lumber Company, and the Elrod Lumber Company. In the 1950s, Elrod employed about one-third of Rison’s population, more than 300.
During World War II, many Rison residents secured war-related jobs in nearby towns. These included the Pine Bluff Arsenal (Jefferson County) and the Naval Ammunition Depot at Camden (Ouachita County). Others went to California to work in the shipbuilding industry. The Rison high school’s football program was suspended until the end of the war due to a lack of players and coaches, as well as financial constraints. One of Rison’s citizens, Airman Roy Martin, was shot down over occupied France and classified as missing in action. The French underground secured his freedom by hiding him in attics, barns, and other places not known to the German occupying forces. When the news of Martin’s survival reached Rison, a wild celebration broke out in streets and homes.
Geography
Rison is located in north-central Cleveland County at . U.S. Route 79 passes through the western side of the city, leading northeast to Pine Bluff and southwest to Fordyce.
According to the United States Census Bureau, the city has a total area of , all land.
Demographics
2020 census
As of the 2020 United States census, there were 967 people, 498 households, and 297 families residing in the city.
2000 census
As of the census of 2000, there were 1,271 people, 471 households, and 324 families residing in the city. The population density was . There were 532 housing units at an average density of . The racial makeup of the city was 62.23% White, 33.36% Black or African American, 0.31% Native American, 0.24% Asian, 1.73% from other races, and 2.12% from two or more races. 2.20% of the population were Hispanic or Latino of any race.
There were 471 households, out of which 36.3% had children under the age of 18 living with them, 45.0% were married couples living together, 19.1% had a female householder with no husband present, and 31.2% were non-families. 30.1% of all households were made up of individuals, and 15.3% had someone living alone who was 65 years of age or older. The average household size was 2.55 and the average family size was 3.16.
In the city, the population was spread out, with 29.3% under the age of 18, 6.8% from 18 to 24, 25.3% from 25 to 44, 19.6% from 45 to 64, and 19.0% who were 65 years of age or older. The median age was 36 years. For every 100 females, there were 79.8 males. For every 100 females age 18 and over, there were 75.2 males.
The median income for a household in the city was $20,865, and the median income for a family was $30,833. Males had a median income of $26,500 versus $18,229 for females. The per capita income for the city was $13,106. About 25.6% of families and 32.9% of the population were below the poverty line, including 46.0% of those under age 18 and 30.5% of those age 65 or over.
Education
Public education for early childhood, elementary and secondary school students in the city limits of Rison is provided by the Cleveland County School District, which is headquartered in Rison. Students graduate from Rison High School. The district was established by the July 1, 2004 consolidation of the Rison School District and the Kingsland School District.
Notable people
Jeremy James, singer/songwriter originally from Rison
Tyrell Johnson, NFL player for the Minnesota Vikings
Jerry Taylor, Arkansas legislator and businessman
Buddy Turner, Arkansas legislator
Ed Wilson, Arkansas Entertainers Hall of Fame
References
Cities in Cleveland County, Arkansas
Cities in Arkansas
County seats in Arkansas
Cities in Pine Bluff metropolitan area
|
Hayat Mirshad (born 1988) is a Lebanese feminist journalist, activist, and co-founder of the non-profit feminist collective FE-MALE.
Education
Mirshad holds a BA in English literature from the Lebanese University and a Gender in Development and Humanitarian Assistance (GDHA) Diploma from the Lebanese American University–Beirut, the latter being a continuing education program at LAU's Institute for Women's Studies in the Arab World (IWSAW).
Activism
Mirshad founded the first feminist radio program in Lebanon in 2012, called "Sharika wa Laken" (A Partner Not Yet Equal), where she serves as editor-in-chief. In 2007, she co-founded the non-profit feminist collective FE-MALE where she remains a co-director. Mirshad is also the head of communications at the Lebanese Women Democratic Gathering and a member of the UN Women's Youth Gender Innovation Agora. She also works with the Men and Women for Gender Equality programme at the UN Women's Regional Office for the Arab States, a project funded by the Swedish International Development Cooperation Agency to research the root causes of gender inequalities in the region and address them using a bottom-up approach.
Mirshad advocates for girls and women to have access to justice, information, protection, and human rights, both online and offline by organizing nationwide marches, rallying support against corrupt, patriarchal regimes.
Awards
In 2020, Mirshad was recognized by the BBC's 100 women 2020. This is recognition as one of the Top 100 influential and inspiring women of the year for her work as the director of FE-MALE.
References
Lebanese women's rights activists
Lebanese activists
Lebanese women activists
Lebanese journalists
Lebanese women journalists
1988 births
Living people
|
The 1981–82 European Cup Winners' Cup was the 22nd season of the UEFA Cup Winners' Cup, a club football competition organised by UEFA for the national cup winners from each of its member associations. Spanish club Barcelona won the title for a second time after beating Belgian side Standard Liège 2–1 in the final at Camp Nou.
Preliminary round
|}
First leg
Second leg
Lokomotive Leipzig won 5–2 on aggregate.
First round
|}
First leg
Second leg
Porto won 3–2 on aggregate.
Second round
|}
First leg
Second leg
Porto won 2–0 on aggregate.
Quarter-finals
|}
First leg
Second leg
Standard Liège won 4–2 on aggregate.
Semi-finals
|}
First leg
Second leg
Final
Top scorers
See also
1981–82 European Cup
1981–82 UEFA Cup
External links
1981–82 competition at UEFA website
Cup Winners' Cup results at Rec.Sport.Soccer Statistics Foundation
Cup Winners Cup Seasons 1981–82–results, protocols
website Football Archive 1981–82 Cup Winners Cup
3
UEFA Cup Winners' Cup seasons
|
```shell
#!/usr/bin/env bash
# Tags: zookeeper
CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
# shellcheck source=../shell_config.sh
. "$CURDIR"/../shell_config.sh
# The test cases in this file cover DDLs running on both Replicated database engine and non-Replicated database engine.
# Since the processing flow is a little bit different from each other, in order to share same reference file,
# we compare the expected result and actual result by ourselves. See check_span method below for more detail.
# This function takes following arguments:
# $1 - OpenTelemetry Trace Id
# $2 - Query
# $3 - Query Settings
function execute_query()
{
local trace_id=$1 && shift
local ddl_version=$1 && shift
local opts=(
--opentelemetry-traceparent "00-$trace_id-5150000000000515-01"
--opentelemetry-tracestate $'a\nb cd'
--distributed_ddl_output_mode "none"
--distributed_ddl_entry_format_version "$ddl_version"
)
${CLICKHOUSE_CLIENT} "${opts[@]}" "$@"
}
# This function takes following argument:
# $1 - expected
# $2 - OpenTelemetry Trace Id
# $3 - operation_name pattern
# $4 - extra condition
function check_span()
{
if [ -n "$4" ]; then
extra_condition=" AND ${4}"
else
extra_condition=""
fi
ret=$(${CLICKHOUSE_CLIENT} -nq "
SYSTEM FLUSH LOGS;
SELECT count()
FROM system.opentelemetry_span_log
WHERE finish_date >= yesterday()
AND lower(hex(trace_id)) = '${2}'
AND operation_name like '${3}'
${extra_condition};")
if [ $ret = $1 ]; then
echo 1
else
echo "[operation_name like '${3}' ${extra_condition}]=$ret, expected: ${1}"
# echo the span logs to help analyze
${CLICKHOUSE_CLIENT} -q "
SELECT operation_name, attribute
FROM system.opentelemetry_span_log
WHERE finish_date >= yesterday()
AND lower(hex(trace_id)) ='${2}'
ORDER BY start_time_us
Format PrettyCompact
"
fi
}
#
# Set up
#
${CLICKHOUSE_CLIENT} -q "
DROP TABLE IF EXISTS ${CLICKHOUSE_DATABASE}.ddl_test_for_opentelemetry;
"
# Support Replicated database engine
cluster_name=$($CLICKHOUSE_CLIENT -q "select if(engine = 'Replicated', name, 'test_shard_localhost') from system.databases where name='$CLICKHOUSE_DATABASE'")
#
# Only format_version 4 enables the tracing
#
for ddl_version in 3 4; do
# Echo a separator so that the reference file is more clear for reading
echo "===ddl_format_version ${ddl_version}===="
trace_id=$(${CLICKHOUSE_CLIENT} -q "select lower(hex(generateUUIDv4()))");
execute_query $trace_id $ddl_version -q "CREATE TABLE ${CLICKHOUSE_DATABASE}.ddl_test_for_opentelemetry ON CLUSTER ${cluster_name} (id UInt64) Engine=MergeTree ORDER BY id"
check_span 1 $trace_id "TCPHandler"
if [ $cluster_name = "test_shard_localhost" ]; then
check_span 1 $trace_id "%executeDDLQueryOnCluster%" "attribute['clickhouse.cluster']='${cluster_name}'"
else
check_span 1 $trace_id "%tryEnqueueAndExecuteEntry%" "attribute['clickhouse.cluster']='${cluster_name}'"
fi
if [ $cluster_name = "test_shard_localhost" ]; then
# The tracing is only enabled when entry format version is 4
if [ $ddl_version = "4" ]; then
expected=1
else
expected=0
fi
else
# For Replicated database engine, the tracing is always enabled because it calls DDLWorker::processTask directly
expected=1
fi
check_span $expected $trace_id "%DDLWorker::processTask%"
# For queries that tracing are enabled(format version is 4 or Replicated database engine), there should be two 'query' spans,
# one is for the TCPHandler, the other is for the DDL executing in DDLWorker.
#
# For other format, there should be only one 'query' span
if [ $cluster_name = "test_shard_localhost" ]; then
if [ $ddl_version = "4" ]; then
expected=2
else
expected=1
fi
else
expected=2
fi
check_span $expected $trace_id "query"
# Remove table
# Under Replicated database engine, the DDL is executed as ON CLUSTER DDL, so distributed_ddl_output_mode is needed to supress output
${CLICKHOUSE_CLIENT} --distributed_ddl_output_mode none -q "
DROP TABLE IF EXISTS ${CLICKHOUSE_DATABASE}.ddl_test_for_opentelemetry;
"
done
#
# an exceptional case, DROP a non-exist table
#
# Echo a separator so that the reference file is more clear for reading
echo "===exception===="
trace_id=$(${CLICKHOUSE_CLIENT} -q "select lower(hex(generateUUIDv4()))");
execute_query $trace_id 4 -q "DROP TABLE ${CLICKHOUSE_DATABASE}.ddl_test_for_opentelemetry_non_exist ON CLUSTER ${cluster_name}" 2>&1 | grep 'DB::Exception ' | grep -Fv "UNKNOWN_TABLE"
check_span 1 $trace_id "TCPHandler"
if [ $cluster_name = "test_shard_localhost" ]; then
expected=1
else
# For Replicated database it will fail on initiator before enqueueing distributed DDL
expected=0
fi
check_span $expected $trace_id "%executeDDLQueryOnCluster%" "attribute['clickhouse.cluster']='${cluster_name}' AND kind = 'PRODUCER'"
check_span $expected $trace_id "%DDLWorker::processTask%" "kind = 'CONSUMER'"
if [ $cluster_name = "test_shard_localhost" ]; then
# There should be two 'query' spans, one is for the TCPHandler, the other is for the DDL executing in DDLWorker.
# Both of these two spans contain exception
expected=2
else
# For Replicated database, there should only one query span
expected=1
fi
# We don't case about the exact value of exception_code, just check it's there.
check_span $expected $trace_id "query" "attribute['clickhouse.exception_code']<>''"
```
|
Parliamentary elections were held in Poland on 5 November 1922, with Senate elections held a week later on 12 November. The elections were governed by the March Constitution of Poland, and saw the Christian Union of National Unity coalition emerge as the largest bloc in the Sejm with 163 of the 444 seats.
The resulting coalitions were unstable, and the situation - difficult from the start, with assassination of Polish president Gabriel Narutowicz in December shortly after the elections - culminated in 1926 with the May Coup.
Results
Sejm
Senate
Ethnoreligious voting analysis
According to Kopstein and Wittenberg, 39% of the majority Catholic population voted for right-wing parties, 29% for non-revolutionary left-wing parties and 25% for centrist parties. The other ethnoreligious groups, including Uniates, Jews and Orthodox Christians voted largely for parties representing minority groups.
Some regional differences were observed; in western Poland, 9% of the Catholic vote went to minority interest parties, which has been attributed in part to German Catholic voting, but in the east, only 1% did. Ethnic Polish support for the right wing was stronger in the east of the country, where 40% voted for right-wing parties, as opposed to the south where 16% did. No detectable regional variation existed among Jews. The lack of support for the center and right among the major minorities (Jews, Ukrainians and Belarusians) was attributed to ethnic polarization that was exacerbated by discrimination and chauvinism from Polish officials. Despite the success of minority parties, parties describing themselves as "Polish" refused to form a government with minority parties, and there was not one non-ethnic Polish cabinet member in the interwar period, though interethnic cooperation could still be seen in Ukrainian and Belarusian support for the Sikorski government.
References
Further reading
A. J. Groth, Polish Elections 1919-1928, Slavic Review, Vol. 24, No. 4 (Dec., 1965), pp. 653–665 JSTOR
Poland
Parliamentary elections in Poland
Poland
Parliamentary
|
```javascript
const { errors } = require('arsenal');
const vault = require('../../../auth/vault');
function checkExpectedBucketOwner(headers, bucket, log, cb) {
const expectedOwner = headers['x-amz-expected-bucket-owner'];
if (expectedOwner === undefined) {
return cb();
}
const bucketOwner = bucket.getOwner();
return vault.getAccountIds([bucketOwner], log, (error, res) => {
if (error) {
log.error('error fetch accountId from vault', {
method: 'checkExpectedBucketOwner',
error,
});
}
if (error || res[bucketOwner] !== expectedOwner) {
return cb(errors.AccessDenied);
}
return cb();
});
}
module.exports = {
checkExpectedBucketOwner,
};
```
|
```objective-c
/*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "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 COPYRIGHT
* OWNER 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.
*/
#ifndef WebContentSecurityPolicy_h
#define WebContentSecurityPolicy_h
namespace blink {
enum WebContentSecurityPolicyType {
WebContentSecurityPolicyTypeReport,
WebContentSecurityPolicyTypeEnforce,
WebContentSecurityPolicyTypeLast = WebContentSecurityPolicyTypeEnforce
};
} // namespace blink
#endif
```
|
The 27th Engineer Battalion (Combat) (Airborne) "Tiger Battalion" is an engineer battalion of the United States Army.
History
The 27th Engineer Battalion was established on January 16, 1918 at Fort Myer, Virginia as the 2D Battalion, 37th Engineer Regiment. In July 1918, during World War I, the unit fought in the Battle of Saint-Mihiel and Meuse-Argonne; the unit was demobilized afterwards at Camp Upton. It was reconstituted in the Regular Army as the 2nd Battalion, 37th Engineers in October 1933, then reactivated on July 14, 1941 at Camp Bowie and assigned to the VIII Corps. The unit was moved to Camp Edwards in 1942 and redesignated as the 2nd Battalion, 37th Engineer Combat Regiment. They were assigned to the VII Corps later that year and moved to Camp Beale. The March 1943 redesignation renamed the HHC as the 1106th Engineer Combat Group; the 1st Battalion as the 37th Engineer Combat Battalion; and the 2nd Battalion as the 209th Engineer Combat Battalion.
The unit was deployed from the New York Port of Embarkation in September 1943 and arrived in Bombay in October, where they joined the India-Burma Campaign. While attached to the 5307th Composite Unit, they helped seize the Myitkyina airfield during the Siege of Myitkyina. Seventy-one members of the 209th were killed in action and 179 wounded during the 70-day-long battle. In 1945, they participated in the Central Burma Campaign before being moved to Ledo Road with the exception of Company A, who remained in Myitkyina. They returned to the United States in November 1945 where they were inactivated at Camp Kilmer. In 1947, they were redesignated as the 27th Engineerg Combat Battalion. They earned a Presidential Unit Citation for their work at the airfield. They were activated for one month while at Ft. Lewis in 1950. They activated in March 1951 at Ft. Campbell and redesignated in June 1953 as the 27th Engineer Battalion. In October 1960, the unit earned the nickname "Tiger Battalion" due to its rugged field manueuvers and training.
They entered the Vietnam War in 1966 and arrived in Bien Hoa that October. They were later based in Xuan Loc with the 79th Engineer Group. They came under the jurisdiction of the 34th Engineer Group in April 1967 and were transferred in April 1968 to support the 45th Engineer Group in Gia Le and the 101st Airborne Division at Camp Eagle. They returend to the United States on January 31, 1972 and settled at Ft. Campbell. The unit received five Meritorious Unit Commendations for action in Vietnam and one for action in Southwest Asia, the Superior Unit Award for AHAUS TAURA '90, and the Civil Action Honor Medal (1st class) with 19 campaign streamers for their efforts. They later moved to Fort Bragg, where the unit became a non-divisional combat airborne engineer battalion. Parts of the unit took part in Operation Bright Star 82 and were deployed to Berbera. While in Somalia, the 27th carried out infrastructural improvement projects for the Somali people. That summer, they provided relief support following Hurricane Agnes, including potable water from purification platoons.
In 1983, the 27th repaired runways after Cuban engineers damaged them with explosives during the Invasion of Grenada. During Operation Desert Shield, while attached to France's 6th Light Armoured Division, they became the lead engineer battalion for the XVIII Airborne Corps. They returned to Fort Bragg in 1991 and created a small memorial to its Desert Storm veterans. The unit was deployed again a year and a half later to Miami-Dade County, Florida for Hurricane Andrew relief efforts. They remained there as part of the Task Force All-American for a year. From September to November 1994, they worked with the 10th Mountain Division (Light) to establish Base Camp Dragon and Castle in Haiti following Operation Uphold Democracy. While there, they constructed a school which was subsequently damaged by Hurricane Bonnie. Security detail was also posted at their compound.
In November 2001, they joined Operations Joint Guardian. Since the beginning of the War on Terror, they have worked on several projects in Iraq and Afghanistan. In January 2003, the 27th's Company C became the first counter-mine company in the Army since the Vietnam War. They used both mechanical clearance equipment and modern mine detectors to clear hundreds of thousands of square meters of land mines and other explosives at Bagram Airfield so the airfield could expand. The soldiers have received decorations such as the Silver Star and Soldier's Medal in addition to unit citations. The company received two Meritorious Unit Commendations for its actions in Afghanistan.
All lettered companies of the 27th were inactivated at Ft. Campbell in October 2008 before being deployed to Afghanistan in December 2009 where they worked on route clearance duty, responsible for clearing roadside bombs and other improvised explosive devices planted by insurgents. The battalion was given a Meritorious Unit Commendation for their service. As of October 1999, they had the last and only airborne well driller detachment/platoon left in the United States Army. As of 2014, the 27th's 57th Sapper Company is the only company in the Army that specializes in rough terrain airborne insertion. In addition to their field action, the HHC 27th Engineer Battalion has built a mock kill house for urban actions training; renovated their company's offices; built a FSC company area; erected a rappel tower at a high school in North Carolina; and extended a runway at a municipal airport in North Carolina.
Organizational structure
XVIII Airborne Corps
20th Engineer Brigade
Headquarters and Headquarters Company, 20th Engineer Brigade
19th Engineer Battalion (Construction Effects)
27th Engineer Battalion (Combat)(Airborne)
Headquarters and Headquarters Company, 27th Engineer Battalion
Forward Support Company, 27th Engineer Battalion
57th Sapper Company (Combat)(Airborne)(Rough Terrain)
133D Engineer Detachment
161st Engineer Support Company (Airborne)
264th Engineer Clearance Company
513th Fire Fighting Detachment
618th Engineer Support Company (Airborne)
92D Engineer Battalion
Insignia
The unit's insignia is a silver-colored metal and enamel device tall. It has a shield and gules, a rock argent, within the garland of oak leaves. Below the insignia is a red scroll with the unit's motto, "Omnes res bene facere" (To Do All Things Well), in silver letters. The shield is red in reference to engineers. The rock was taken from the Arms of Saint-Mihiel and the oak leaves from Meuse-Argonne; both of these areas were where the unit served during World War I. The insignia's border indicates the descent of the 209th Engineer Battalion from the 37th Engineer Regiment. The insignia was approved in March 1951 and redesignated for combat in July 1955 and again in February 1972.
Similarly, the unit's coat of arms has a gules shown within an oak leaf garland with acorns. A chinthe appears sejant with an azure mural crown around its neck. A bamboo grove appears in the background and arches above the chinthe. The base is between four billets, each charged with three barrulets of the second. The chinthe references the chinthe on the Burmese State Seal; the blue of the mural crown represents the heavily fortified town of Myitkyina, where the unit worked during World War II. Blue is also the color of the Presidential Unit Citation (Army) streamer, which they were awarded for their work. The bamboo grove refers to the emblem of Vietnam as a nod to the work the unit did during the Vietnam War. The yellow and red billets refer to the five Vietnam decorations received by the unit: the four Meritorious Unit Commendations and the Civil Actions Medal. The coat of arms was approved in February 1945 and redesignated in both March 1951 and July 1955. It was redesignated again and amended to add a crest in November 1973.
Honors
Campaign participation credit
World War I:
Saint-Mihiel;
Meuse-Argonne
World War II:
India-Burma;
Central Burma
Vietnam:
Counteroffensive, Phase II;
Counteroffensive, Phase III;
Tet Counteroffensive;
Counteroffensive, Phase IV;
Counteroffensive, Phase V;
Counteroffensive, Phase VI;
Tet 69/Counteroffensive;
Summer-Fall 1969;
Winter-Spring 1970;
Sanctuary Counteroffensive;
Counteroffensive, Phase VII;
Consolidation I;
Consolidation II
Southwest Asia:
Defense of Saudi Arabia;
Liberation
Defense of Kuwait
Operation Enduring Freedom
Decorations
Presidential Unit Citation (Army) for
MYITKYINA
Meritorious Unit Commendation (Army) for
VIETNAM 1966–1967
VIETNAM 1967–1968
VIETNAM 1968–1969
VIETNAM 1969
VIETNAM 1970–1971
SOUTHWEST ASIA
AFGHANISTAN 2004
AFGHANISTAN 2009–2010
Army Superior Unit Award for
Hurricane Andrew Relief 1990
Republic of Vietnam Civil Action Honor Medal, First Class for
VIETNAM 1967–1968
VIETNAM 1970
References
External links
Official Website
027
|
```c++
/*Segment tree or segtree is a basically a binary tree used for storing the intervals or segments. Each node in the segment tree represents an interval.
Consider an array A of size N and a corresponding segtree T:
The root of T will represent the whole array A[0:N-1].
Each leaf in the segtree T will represent a single element A[i] such that 0 <= i < N.
The internal nodes in the segtree tree T represent union of elementary intervals A[i:j] where 0 <= i < j < N.*/
#include <iostream>
#include <math.h>
using namespace std;
#define MAX 100
int tree[MAX] = {0};
int lazy[MAX] = {0};
//Updating the tree by incrementing elements within range [l, r] with value val
int update(int node, int start, int end, int l, int r, int val);
//Function to find sum and maximum value in the array within the query [l,r]
int func(int start, int end, int l, int r, int node, int choice);
//Constructing tree
void construct(int arr[], int start, int end, int node);
int main()
{
int arr[] = {1, 2, 3, 4, 5};
int n = sizeof(arr)/sizeof(arr[0]);
int node = 0;
int start = 0;
//Constructing the tree
construct(arr, start, n - 1, node);
// Updating the value in the array from index 0 to index 3 by adding value 4 in it.
update(node, start, n - 1, 0, 3, 4);
//After updating the array becomes [5,6,7,8,5]
cout << "1.Sum\n";
cout << "2.Maximum\n";
cout << "3.Quit";
int choice;
do
{
cout << "\nEnter your choice: ";
cin >> choice;
switch(choice)
{
case 1: // To get the sum of updated array from index 1 to index 4
// Sum of updated array [5,6,7,8,5]
cout << "\nUpdated sum of value in given range = " << func(start, n-1, 1, 4,node,choice);
break;
case 2: // To get the maximum value in updated array from index 1 to index 4
// Maximum value of the updated array
cout << "\nUpdated maximum value in given range = " << func(start, n-1, 1, 4,node,choice);
break;
case 3: cout << "Exit \n";
break;
}
} while(choice != 3);
return 0;
}
// A recursive function that constructs Segment Tree for
// array[start..end].
void construct(int arr[], int start, int end, int node)
{
// out of range as start can never be greater than end
if (start > end)
return ;
// If there is one element in array, store it in
// current node of segment tree and return
if (start == end)
{
tree[node] = arr[start];
return;
}
// If there are more than one elements, then
// left and right subtrees and store the sum
// of values in this node
int mid = (start + end) / 2;
construct(arr, start, mid, node * 2 + 1);
construct(arr, mid + 1, end, node * 2 + 2);
tree[node] = tree[node * 2 + 1] + tree[node * 2 + 2];
}
//Function to find sum and maximum value in the array within the query [l, r]
int func(int start, int end, int l, int r, int node, int choice)
{
if (lazy[node] != 0)
{
// Make pending updates to this node.
tree[node] += (end - start + 1) * lazy[node];
if (start != end)
{
// Mark child as lazy
lazy[node * 2 + 1] += lazy[node];
// Mark child as lazy
lazy[node * 2 + 2] += lazy[node];
}
// Reset it
lazy[node] = 0;
}
// Current segment is not within range [l, r]
if (start > end || start > r || end < l)
return 0;
// Current segment is totally within range [l, r]
if (start >= l && end <= r)
return tree[node];
int mid = (start + end) / 2;
//To find sum
if (choice == 1)
return func(start, mid, l, r, 2*node+1, choice) + func(mid+1, end, l, r, 2*node+2, choice);
//To find max value
if (choice == 2)
return max(func(start, mid, l, r, 2*node+1, choice),func(mid+1, end, l, r, 2*node+2, choice));
}
int update(int node, int start, int end, int l, int r, int val)
{
if (lazy[node] != 0)
{
// This node needs to be updated
// Update it
tree[node] += (end - start + 1) * lazy[node];
if (start != end)
{
lazy[node * 2 + 1] += lazy[node];
lazy[node * 2 + 2] += lazy[node];
}
lazy[node] = 0;
}
// out of range
if (start > end || start > r || end < l)
return 0;
/ Current segment is totally within range [l, r]
if (start >= l && end <= r)
{
tree[node] += (end - start + 1)*val;
if (start != end)
{
// Not leaf node
lazy[node * 2 + 1] += val;
lazy[node * 2 + 2] += val;
}
return 0;
}
// If not a leaf node, recur for children.
int mid = (start + end) / 2;
// Updating left child
update(node * 2 + 1, start, mid, l, r, val);
// Updating right child
update(node * 2 + 2, mid + 1, end, l, r, val);
// Use the result of children calls to update this node
tree[node] = tree[node * 2 + 1] + tree[node * 2 + 2];
}
/*
1.Sum
2.Maximum
3.Quit
Enter your choice: 1
Updated sum of value in given range = 26
Enter your choice: 2
Updated maximum value in given range = 8
*/
```
|
```java
/*
* one or more contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright ownership.
*/
package io.camunda.zeebe.engine.processing.timer;
import io.camunda.zeebe.engine.processing.bpmn.behavior.BpmnBehaviors;
import io.camunda.zeebe.engine.processing.common.CatchEventBehavior;
import io.camunda.zeebe.engine.processing.common.EventHandle;
import io.camunda.zeebe.engine.processing.common.ExpressionProcessor;
import io.camunda.zeebe.engine.processing.common.Failure;
import io.camunda.zeebe.engine.processing.deployment.model.element.ExecutableCatchEvent;
import io.camunda.zeebe.engine.processing.streamprocessor.TypedRecordProcessor;
import io.camunda.zeebe.engine.processing.streamprocessor.writers.StateWriter;
import io.camunda.zeebe.engine.processing.streamprocessor.writers.TypedRejectionWriter;
import io.camunda.zeebe.engine.processing.streamprocessor.writers.Writers;
import io.camunda.zeebe.engine.state.immutable.ElementInstanceState;
import io.camunda.zeebe.engine.state.immutable.ProcessState;
import io.camunda.zeebe.engine.state.mutable.MutableProcessingState;
import io.camunda.zeebe.engine.state.mutable.MutableTimerInstanceState;
import io.camunda.zeebe.model.bpmn.util.time.Interval;
import io.camunda.zeebe.model.bpmn.util.time.RepeatingInterval;
import io.camunda.zeebe.model.bpmn.util.time.Timer;
import io.camunda.zeebe.protocol.impl.record.value.timer.TimerRecord;
import io.camunda.zeebe.protocol.record.RejectionType;
import io.camunda.zeebe.protocol.record.intent.TimerIntent;
import io.camunda.zeebe.stream.api.records.TypedRecord;
import io.camunda.zeebe.stream.api.state.KeyGenerator;
import io.camunda.zeebe.util.Either;
import io.camunda.zeebe.util.buffer.BufferUtil;
import java.time.Instant;
import org.agrona.DirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
public final class TimerTriggerProcessor implements TypedRecordProcessor<TimerRecord> {
private static final String NO_TIMER_FOUND_MESSAGE =
"Expected to trigger timer with key '%d', but no such timer was found";
private static final String NO_ACTIVE_TIMER_MESSAGE =
"Expected to trigger a timer with key '%d', but the timer is not active anymore";
private static final DirectBuffer NO_VARIABLES = new UnsafeBuffer();
private final CatchEventBehavior catchEventBehavior;
private final ProcessState processState;
private final ElementInstanceState elementInstanceState;
private final MutableTimerInstanceState timerInstanceState;
private final ExpressionProcessor expressionProcessor;
private final KeyGenerator keyGenerator;
private final StateWriter stateWriter;
private final TypedRejectionWriter rejectionWriter;
private final EventHandle eventHandle;
public TimerTriggerProcessor(
final MutableProcessingState processingState,
final BpmnBehaviors bpmnBehaviors,
final Writers writers) {
catchEventBehavior = bpmnBehaviors.catchEventBehavior();
expressionProcessor = bpmnBehaviors.expressionBehavior();
stateWriter = writers.state();
rejectionWriter = writers.rejection();
processState = processingState.getProcessState();
elementInstanceState = processingState.getElementInstanceState();
timerInstanceState = processingState.getTimerState();
keyGenerator = processingState.getKeyGenerator();
eventHandle =
new EventHandle(
keyGenerator,
processingState.getEventScopeInstanceState(),
writers,
processState,
bpmnBehaviors.eventTriggerBehavior(),
bpmnBehaviors.stateBehavior());
}
@Override
public void processRecord(final TypedRecord<TimerRecord> record) {
final var timer = record.getValue();
final var elementInstanceKey = timer.getElementInstanceKey();
final var processDefinitionKey = timer.getProcessDefinitionKey();
final var timerInstance = timerInstanceState.get(elementInstanceKey, record.getKey());
if (timerInstance == null) {
rejectionWriter.appendRejection(
record, RejectionType.NOT_FOUND, String.format(NO_TIMER_FOUND_MESSAGE, record.getKey()));
return;
}
final var catchEvent =
processState.getFlowElement(
processDefinitionKey,
timer.getTenantId(),
timer.getTargetElementIdBuffer(),
ExecutableCatchEvent.class);
if (isStartEvent(elementInstanceKey)) {
final long processInstanceKey = keyGenerator.nextKey();
timer.setProcessInstanceKey(processInstanceKey);
stateWriter.appendFollowUpEvent(record.getKey(), TimerIntent.TRIGGERED, timer);
eventHandle.activateProcessInstanceForStartEvent(
processDefinitionKey,
processInstanceKey,
timer.getTargetElementIdBuffer(),
NO_VARIABLES,
timer.getTenantId());
} else {
final var elementInstance = elementInstanceState.getInstance(elementInstanceKey);
if (!eventHandle.canTriggerElement(elementInstance, timer.getTargetElementIdBuffer())) {
rejectNoActiveTimer(record);
return;
}
stateWriter.appendFollowUpEvent(record.getKey(), TimerIntent.TRIGGERED, timer);
eventHandle.activateElement(catchEvent, elementInstanceKey, elementInstance.getValue());
}
if (shouldReschedule(timer)) {
rescheduleTimer(timer, catchEvent);
}
}
private void rejectNoActiveTimer(final TypedRecord<TimerRecord> record) {
rejectionWriter.appendRejection(
record,
RejectionType.INVALID_STATE,
String.format(NO_ACTIVE_TIMER_MESSAGE, record.getKey()));
}
private boolean isStartEvent(final long elementInstanceKey) {
return elementInstanceKey < 0;
}
private boolean shouldReschedule(final TimerRecord timer) {
return timer.getRepetitions() == RepeatingInterval.INFINITE || timer.getRepetitions() > 1;
}
private void rescheduleTimer(final TimerRecord record, final ExecutableCatchEvent event) {
final Either<Failure, Timer> timer =
event.getTimerFactory().apply(expressionProcessor, record.getElementInstanceKey());
if (timer.isLeft()) {
final String message =
String.format(
"Expected to reschedule repeating timer for element with id '%s', but an error occurred: %s",
BufferUtil.bufferAsString(event.getId()), timer.getLeft().getMessage());
throw new IllegalStateException(message);
// todo(#4208): raise incident instead of throwing an exception
}
final Timer refreshedTimer = refreshTimer(timer.get(), record);
catchEventBehavior.subscribeToTimerEvent(
record.getElementInstanceKey(),
record.getProcessInstanceKey(),
record.getProcessDefinitionKey(),
event.getId(),
record.getTenantId(),
refreshedTimer);
}
private Timer refreshTimer(final Timer timer, final TimerRecord record) {
if (timer instanceof CronTimer) {
return timer;
}
int repetitions = record.getRepetitions();
if (repetitions != RepeatingInterval.INFINITE) {
repetitions--;
}
// Use the timer's last due date instead of the current time to avoid a time shift.
final Interval refreshedInterval =
timer.getInterval().withStart(Instant.ofEpochMilli(record.getDueDate()));
return new RepeatingInterval(repetitions, refreshedInterval);
}
}
```
|
```go
//
//
// 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 project
import (
"github.com/goharbor/harbor/src/common"
"github.com/goharbor/harbor/src/common/rbac"
"github.com/goharbor/harbor/src/pkg/permission/types"
)
var (
rolePoliciesMap = map[string][]*types.Policy{
"projectAdmin": {
{Resource: rbac.ResourceSelf, Action: rbac.ActionRead},
{Resource: rbac.ResourceSelf, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceSelf, Action: rbac.ActionDelete},
{Resource: rbac.ResourceMember, Action: rbac.ActionCreate},
{Resource: rbac.ResourceMember, Action: rbac.ActionRead},
{Resource: rbac.ResourceMember, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceMember, Action: rbac.ActionDelete},
{Resource: rbac.ResourceMember, Action: rbac.ActionList},
{Resource: rbac.ResourceMetadata, Action: rbac.ActionCreate},
{Resource: rbac.ResourceMetadata, Action: rbac.ActionRead},
{Resource: rbac.ResourceMetadata, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceMetadata, Action: rbac.ActionDelete},
{Resource: rbac.ResourceLog, Action: rbac.ActionList},
{Resource: rbac.ResourceLabel, Action: rbac.ActionCreate},
{Resource: rbac.ResourceLabel, Action: rbac.ActionRead},
{Resource: rbac.ResourceLabel, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceLabel, Action: rbac.ActionDelete},
{Resource: rbac.ResourceLabel, Action: rbac.ActionList},
{Resource: rbac.ResourceQuota, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionCreate},
{Resource: rbac.ResourceRepository, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceRepository, Action: rbac.ActionDelete},
{Resource: rbac.ResourceRepository, Action: rbac.ActionList},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPull},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPush},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionCreate},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionRead},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionDelete},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionList},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionOperate},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionCreate},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionDelete},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionList},
{Resource: rbac.ResourceConfiguration, Action: rbac.ActionRead},
{Resource: rbac.ResourceConfiguration, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceRobot, Action: rbac.ActionCreate},
{Resource: rbac.ResourceRobot, Action: rbac.ActionRead},
{Resource: rbac.ResourceRobot, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceRobot, Action: rbac.ActionDelete},
{Resource: rbac.ResourceRobot, Action: rbac.ActionList},
{Resource: rbac.ResourceNotificationPolicy, Action: rbac.ActionCreate},
{Resource: rbac.ResourceNotificationPolicy, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceNotificationPolicy, Action: rbac.ActionDelete},
{Resource: rbac.ResourceNotificationPolicy, Action: rbac.ActionList},
{Resource: rbac.ResourceNotificationPolicy, Action: rbac.ActionRead},
{Resource: rbac.ResourceScan, Action: rbac.ActionCreate},
{Resource: rbac.ResourceScan, Action: rbac.ActionRead},
{Resource: rbac.ResourceScan, Action: rbac.ActionStop},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionCreate},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionStop},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionRead},
{Resource: rbac.ResourceScanner, Action: rbac.ActionRead},
{Resource: rbac.ResourceScanner, Action: rbac.ActionCreate},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionCreate},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionRead},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionDelete},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifactAddition, Action: rbac.ActionRead},
{Resource: rbac.ResourceTag, Action: rbac.ActionList},
{Resource: rbac.ResourceTag, Action: rbac.ActionCreate},
{Resource: rbac.ResourceTag, Action: rbac.ActionDelete},
{Resource: rbac.ResourceAccessory, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifactLabel, Action: rbac.ActionCreate},
{Resource: rbac.ResourceArtifactLabel, Action: rbac.ActionDelete},
{Resource: rbac.ResourcePreatPolicy, Action: rbac.ActionCreate},
{Resource: rbac.ResourcePreatPolicy, Action: rbac.ActionRead},
{Resource: rbac.ResourcePreatPolicy, Action: rbac.ActionUpdate},
{Resource: rbac.ResourcePreatPolicy, Action: rbac.ActionDelete},
{Resource: rbac.ResourcePreatPolicy, Action: rbac.ActionList},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionCreate},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionRead},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionList},
},
"maintainer": {
{Resource: rbac.ResourceSelf, Action: rbac.ActionRead},
{Resource: rbac.ResourceMember, Action: rbac.ActionRead},
{Resource: rbac.ResourceMember, Action: rbac.ActionList},
{Resource: rbac.ResourceMetadata, Action: rbac.ActionRead},
{Resource: rbac.ResourceLog, Action: rbac.ActionList},
{Resource: rbac.ResourceQuota, Action: rbac.ActionRead},
{Resource: rbac.ResourceLabel, Action: rbac.ActionCreate},
{Resource: rbac.ResourceLabel, Action: rbac.ActionRead},
{Resource: rbac.ResourceLabel, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceLabel, Action: rbac.ActionDelete},
{Resource: rbac.ResourceLabel, Action: rbac.ActionList},
{Resource: rbac.ResourceRepository, Action: rbac.ActionCreate},
{Resource: rbac.ResourceRepository, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceRepository, Action: rbac.ActionDelete},
{Resource: rbac.ResourceRepository, Action: rbac.ActionList},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPush},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPull},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionCreate},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionRead},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionDelete},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionList},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionOperate},
{Resource: rbac.ResourceAccessory, Action: rbac.ActionList},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionCreate},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionDelete},
{Resource: rbac.ResourceImmutableTag, Action: rbac.ActionList},
{Resource: rbac.ResourceConfiguration, Action: rbac.ActionRead},
{Resource: rbac.ResourceRobot, Action: rbac.ActionRead},
{Resource: rbac.ResourceRobot, Action: rbac.ActionList},
{Resource: rbac.ResourceNotificationPolicy, Action: rbac.ActionList},
{Resource: rbac.ResourceScan, Action: rbac.ActionCreate},
{Resource: rbac.ResourceScan, Action: rbac.ActionRead},
{Resource: rbac.ResourceScan, Action: rbac.ActionStop},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionCreate},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionStop},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionRead},
{Resource: rbac.ResourceScanner, Action: rbac.ActionRead},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionCreate},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionRead},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionDelete},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifactAddition, Action: rbac.ActionRead},
{Resource: rbac.ResourceTag, Action: rbac.ActionList},
{Resource: rbac.ResourceTag, Action: rbac.ActionCreate},
{Resource: rbac.ResourceTag, Action: rbac.ActionDelete},
{Resource: rbac.ResourceArtifactLabel, Action: rbac.ActionCreate},
{Resource: rbac.ResourceArtifactLabel, Action: rbac.ActionDelete},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionCreate},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionRead},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionList},
},
"developer": {
{Resource: rbac.ResourceSelf, Action: rbac.ActionRead},
{Resource: rbac.ResourceMember, Action: rbac.ActionRead},
{Resource: rbac.ResourceMember, Action: rbac.ActionList},
{Resource: rbac.ResourceLog, Action: rbac.ActionList},
{Resource: rbac.ResourceLabel, Action: rbac.ActionRead},
{Resource: rbac.ResourceLabel, Action: rbac.ActionList},
{Resource: rbac.ResourceQuota, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionCreate},
{Resource: rbac.ResourceRepository, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceRepository, Action: rbac.ActionList},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPush},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPull},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionCreate},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionRead},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionUpdate},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionDelete},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionList},
{Resource: rbac.ResourceTagRetention, Action: rbac.ActionOperate},
{Resource: rbac.ResourceConfiguration, Action: rbac.ActionRead},
{Resource: rbac.ResourceRobot, Action: rbac.ActionRead},
{Resource: rbac.ResourceRobot, Action: rbac.ActionList},
{Resource: rbac.ResourceScan, Action: rbac.ActionRead},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionRead},
{Resource: rbac.ResourceScanner, Action: rbac.ActionRead},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionCreate},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionRead},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifactAddition, Action: rbac.ActionRead},
{Resource: rbac.ResourceTag, Action: rbac.ActionList},
{Resource: rbac.ResourceTag, Action: rbac.ActionCreate},
{Resource: rbac.ResourceAccessory, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifactLabel, Action: rbac.ActionCreate},
{Resource: rbac.ResourceArtifactLabel, Action: rbac.ActionDelete},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionCreate},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionRead},
{Resource: rbac.ResourceExportCVE, Action: rbac.ActionList},
},
"guest": {
{Resource: rbac.ResourceSelf, Action: rbac.ActionRead},
{Resource: rbac.ResourceMember, Action: rbac.ActionRead},
{Resource: rbac.ResourceMember, Action: rbac.ActionList},
{Resource: rbac.ResourceLog, Action: rbac.ActionList},
{Resource: rbac.ResourceLabel, Action: rbac.ActionRead},
{Resource: rbac.ResourceLabel, Action: rbac.ActionList},
{Resource: rbac.ResourceQuota, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionList},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPull},
{Resource: rbac.ResourceConfiguration, Action: rbac.ActionRead},
{Resource: rbac.ResourceRobot, Action: rbac.ActionRead},
{Resource: rbac.ResourceRobot, Action: rbac.ActionList},
{Resource: rbac.ResourceScan, Action: rbac.ActionRead},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionRead},
{Resource: rbac.ResourceScanner, Action: rbac.ActionRead},
{Resource: rbac.ResourceTag, Action: rbac.ActionList},
{Resource: rbac.ResourceAccessory, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionRead},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifactAddition, Action: rbac.ActionRead},
},
"limitedGuest": {
{Resource: rbac.ResourceSelf, Action: rbac.ActionRead},
{Resource: rbac.ResourceQuota, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionList},
{Resource: rbac.ResourceRepository, Action: rbac.ActionRead},
{Resource: rbac.ResourceRepository, Action: rbac.ActionPull},
{Resource: rbac.ResourceConfiguration, Action: rbac.ActionRead},
{Resource: rbac.ResourceScan, Action: rbac.ActionRead},
{Resource: rbac.ResourceSBOM, Action: rbac.ActionRead},
{Resource: rbac.ResourceScanner, Action: rbac.ActionRead},
{Resource: rbac.ResourceTag, Action: rbac.ActionList},
{Resource: rbac.ResourceAccessory, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionRead},
{Resource: rbac.ResourceArtifact, Action: rbac.ActionList},
{Resource: rbac.ResourceArtifactAddition, Action: rbac.ActionRead},
},
}
)
// projectRBACRole implement the RBACRole interface
type projectRBACRole struct {
projectID int64
roleID int
}
// GetRoleName returns role name for the visitor role
func (role *projectRBACRole) GetRoleName() string {
switch role.roleID {
case common.RoleProjectAdmin:
return "projectAdmin"
case common.RoleMaintainer:
return "maintainer"
case common.RoleDeveloper:
return "developer"
case common.RoleGuest:
return "guest"
case common.RoleLimitedGuest:
return "limitedGuest"
default:
return ""
}
}
// GetPolicies returns policies for the visitor role
func (role *projectRBACRole) GetPolicies() []*types.Policy {
policies := []*types.Policy{}
roleName := role.GetRoleName()
if roleName == "" {
return policies
}
namespace := NewNamespace(role.projectID)
for _, policy := range rolePoliciesMap[roleName] {
policies = append(policies, &types.Policy{
Resource: namespace.Resource(policy.Resource),
Action: policy.Action,
Effect: policy.Effect,
})
}
return policies
}
```
|
Euler's factorization method is a technique for factoring a number by writing it as a sum of two squares in two different ways. For example the number can be written as or as and Euler's method gives the factorization .
The idea that two distinct representations of an odd positive integer may lead to a factorization was apparently first proposed by Marin Mersenne. However, it was not put to use extensively until one hundred years later by Euler. His most celebrated use of the method that now bears his name was to factor the number , which apparently was previously thought to be prime even though it is not a pseudoprime by any major primality test.
Euler's factorization method is more effective than Fermat's for integers whose factors are not close together and potentially much more efficient than trial division if one can find representations of numbers as sums of two squares reasonably easily. Euler's development ultimately permitted much more efficient factoring of numbers and, by the 1910s, the development of large factor tables going up to about ten million. The methods used to find representations of numbers as sums of two squares are essentially the same as with finding differences of squares in Fermat's factorization method.
Disadvantage and limitation
The great disadvantage of Euler's factorization method is that it cannot be applied to factoring an integer with any prime factor of the form 4k + 3 occurring to an odd power in its prime factorization, as such a number can never be the sum of two squares. Even odd composite numbers of the form 4k + 1 are often the product of two primes of the form 4k + 3 (e.g. 3053 = 43 × 71) and again cannot be factored by Euler's method.
This restricted applicability has made Euler's factorization method disfavoured for computer factoring algorithms, since any user attempting to factor a random integer is unlikely to know whether Euler's method can actually be applied to the integer in question. It is only relatively recently that there have been attempts to develop Euler's method into computer algorithms for use on specialised numbers where it is known Euler's method can be applied.
Theoretical basis
The Brahmagupta–Fibonacci identity states that the product of two sums of two squares is a sum of two squares. Euler's method relies on this theorem but it can be viewed as the converse, given we find as a product of sums of two squares.
First deduce that
and factor both sides to get
(1)
Now let and so that there exists some constants satisfying
,
,
,
,
Substituting these into equation (1) gives
Canceling common factors yields
Now using the fact that and are pairs of relatively prime numbers, we find that
So
We now see that and
Applying the Brahmagupta–Fibonacci identity we get
As each factor is a sum of two squares, one of these must contain both even numbers: either or . Without loss of generality, assume that pair is even. The factorization then becomes
Worked example
Since:
we have from the formula above:
Thus,
Pseudocode
function Euler_factorize(int n) -> list[int]
if is_prime(n) then
print("Number is not factorable")
exit function
for-loop from a=1 to a=ceiling(sqrt(n))
b2 = n - a*a
b = floor(sqrt(b2))
if b*b==b2
break loop preserving a,b
if a*a+b*b!=n then
print("Failed to find any expression for n as sum of squares")
exit function
for-loop from c=a+1 to c=ceiling(sqrt(n))
d2 = n - c*c
d = floor(sqrt(d2))
if d*d==d2 then
break loop preserving c,d
if c*c+d*d!=n then
print("Failed to find a second expression for n as sum of squares")
exit function
A = c-a, B = c+a
C = b-d, D = b+d
k = GCD(A,C)//2, h = GCD(B,D)//2
l = GCD(A,D)//2, m = GCD(B,C)//2
factor1 = k*k + h*h
factor2 = l*l + m*m
return list[ factor1, factor2 ]
References
Euler's factorization method
|
```php
<?php
/**
*/
// use OCP namespace for all classes that are considered public.
// This means that they should be used by apps instead of the internal Nextcloud classes
namespace OCP\Files;
use OCP\Files\Search\ISearchQuery;
/**
* @since 6.0.0
*/
interface Folder extends Node {
/**
* Get the full path of an item in the folder within owncloud's filesystem
*
* @param string $path relative path of an item in the folder
* @return string
* @throws \OCP\Files\NotPermittedException
* @since 6.0.0
*/
public function getFullPath($path);
/**
* Get the path of an item in the folder relative to the folder
*
* @param string $path absolute path of an item in the folder
* @throws \OCP\Files\NotFoundException
* @return string|null
* @since 6.0.0
*/
public function getRelativePath($path);
/**
* check if a node is a (grand-)child of the folder
*
* @param \OCP\Files\Node $node
* @return bool
* @since 6.0.0
*/
public function isSubNode($node);
/**
* get the content of this directory
*
* @throws \OCP\Files\NotFoundException
* @return \OCP\Files\Node[]
* @since 6.0.0
*/
public function getDirectoryListing();
/**
* Get the node at $path
*
* @param string $path relative path of the file or folder
* @return \OCP\Files\Node
* @throws \OCP\Files\NotFoundException
* @since 6.0.0
*/
public function get($path);
/**
* Check if a file or folder exists in the folder
*
* @param string $path relative path of the file or folder
* @return bool
* @since 6.0.0
*/
public function nodeExists($path);
/**
* Create a new folder
*
* @param string $path relative path of the new folder
* @return \OCP\Files\Folder
* @throws \OCP\Files\NotPermittedException
* @since 6.0.0
*/
public function newFolder($path);
/**
* Create a new file
*
* @param string $path relative path of the new file
* @param string|resource|null $content content for the new file, since 19.0.0
* @return \OCP\Files\File
* @throws \OCP\Files\NotPermittedException
* @since 6.0.0
*/
public function newFile($path, $content = null);
/**
* search for files with the name matching $query
*
* @param string|ISearchQuery $query
* @return \OCP\Files\Node[]
* @since 6.0.0
*/
public function search($query);
/**
* search for files by mimetype
* $mimetype can either be a full mimetype (image/png) or a wildcard mimetype (image)
*
* @param string $mimetype
* @return \OCP\Files\Node[]
* @since 6.0.0
*/
public function searchByMime($mimetype);
/**
* search for files by tag
*
* @param string|int $tag tag name or tag id
* @param string $userId owner of the tags
* @return \OCP\Files\Node[]
* @since 8.0.0
*/
public function searchByTag($tag, $userId);
/**
* search for files by system tag
*
* @param string|int $tag tag name
* @param string $userId user id to ensure access on returned nodes
* @return \OCP\Files\Node[]
* @since 28.0.0
*/
public function searchBySystemTag(string $tagName, string $userId, int $limit = 0, int $offset = 0);
/**
* get a file or folder inside the folder by its internal id
*
* This method could return multiple entries. For example once the file/folder
* is shared or mounted (files_external) to the user multiple times.
*
* Note that the different entries can have different permissions.
*
* @param int $id
* @return \OCP\Files\Node[]
* @since 6.0.0
*/
public function getById($id);
/**
* get a file or folder inside the folder by its internal id
*
* Unlike getById, this method only returns a single node even if the user has
* access to the file with the requested id multiple times.
*
* This method provides no guarantee about which of the nodes in returned and the
* returned node might, for example, have less permissions than other nodes for the same file
*
* Apps that require accurate information about the users access to the file should use getById
* instead of pick the correct node out of the result.
*
* @param int $id
* @return Node|null
* @since 29.0.0
*/
public function getFirstNodeById(int $id): ?Node;
/**
* Get the amount of free space inside the folder
*
* @return int
* @since 6.0.0
*/
public function getFreeSpace();
/**
* Check if new files or folders can be created within the folder
*
* @return bool
* @since 6.0.0
*/
public function isCreatable();
/**
* Add a suffix to the name in case the file exists
*
* @param string $name
* @return string
* @throws NotPermittedException
* @since 8.1.0
*/
public function getNonExistingName($name);
/**
* @param int $limit
* @param int $offset
* @return \OCP\Files\Node[]
* @since 9.1.0
*/
public function getRecent($limit, $offset = 0);
}
```
|
```objective-c
//===-- ScriptedThread.h ----------------------------------------*- C++ -*-===//
//
// See path_to_url for license information.
//
//===your_sha256_hash------===//
#ifndef LLDB_SOURCE_PLUGINS_SCRIPTED_THREAD_H
#define LLDB_SOURCE_PLUGINS_SCRIPTED_THREAD_H
#include <string>
#include "ScriptedProcess.h"
#include "Plugins/Process/Utility/RegisterContextMemory.h"
#include "lldb/Interpreter/ScriptInterpreter.h"
#include "lldb/Target//DynamicRegisterInfo.h"
#include "lldb/Target/Thread.h"
namespace lldb_private {
class ScriptedProcess;
}
namespace lldb_private {
class ScriptedThread : public lldb_private::Thread {
public:
ScriptedThread(ScriptedProcess &process,
lldb::ScriptedThreadInterfaceSP interface_sp, lldb::tid_t tid,
StructuredData::GenericSP script_object_sp = nullptr);
~ScriptedThread() override;
static llvm::Expected<std::shared_ptr<ScriptedThread>>
Create(ScriptedProcess &process,
StructuredData::Generic *script_object = nullptr);
lldb::RegisterContextSP GetRegisterContext() override;
lldb::RegisterContextSP
CreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
bool LoadArtificialStackFrames();
bool CalculateStopInfo() override;
const char *GetInfo() override { return nullptr; }
const char *GetName() override;
const char *GetQueueName() override;
void WillResume(lldb::StateType resume_state) override;
void RefreshStateAfterStop() override;
void ClearStackFrames() override;
StructuredData::ObjectSP FetchThreadExtendedInfo() override;
private:
void CheckInterpreterAndScriptObject() const;
lldb::ScriptedThreadInterfaceSP GetInterface() const;
ScriptedThread(const ScriptedThread &) = delete;
const ScriptedThread &operator=(const ScriptedThread &) = delete;
std::shared_ptr<DynamicRegisterInfo> GetDynamicRegisterInfo();
const ScriptedProcess &m_scripted_process;
lldb::ScriptedThreadInterfaceSP m_scripted_thread_interface_sp = nullptr;
lldb_private::StructuredData::GenericSP m_script_object_sp = nullptr;
std::shared_ptr<DynamicRegisterInfo> m_register_info_sp = nullptr;
};
} // namespace lldb_private
#endif // LLDB_SOURCE_PLUGINS_SCRIPTED_THREAD_H
```
|
Zabagno is a village in the administrative district of Gmina Tczew, within Tczew County, Pomeranian Voivodeship, in northern Poland. It lies approximately south-west of Tczew and south of the regional capital Gdańsk.
For details of the history of the region, see History of Pomerania.
References
Zabagno
|
```ocaml
open Stdune
module Action = Dune_engine.Action
module Make (S : Action.Ext.Spec) = struct
module Spec = struct
include S
let encode t f g =
let open Sexp in
List [ Atom name; Atom (Int.to_string version); S.encode t f g ]
;;
end
let action p =
let module M = struct
type path = Path.t
type target = Path.Build.t
module Spec = Spec
let v = p
end
in
Action.Extension (module M)
;;
end
```
|
The Hughenden Solar Farm is a solar farm at Hughenden in North West Queensland, Australia. The power station was constructed by BayWa, beginning in 2017. Construction was completed in 2018. Lighthouse Infrastructure bought the solar farm from Baywa who continue to operate and manage the plant.
The power station can generate 20.16 megawatts.
CS Energy has signed a Power Purchase Agreement with Hughenden Solar Farm.
See also
List of solar farms in Queensland
References
Shire of Flinders (Queensland)
Solar power stations in Queensland
2018 establishments in Australia
Energy infrastructure completed in 2018
|
```kotlin
plugins {
id("com.android.application")
id("kotlin-android")
id("com.google.gms.google-services")
}
android {
namespace = "com.google.firebase.fiamquickstart"
compileSdk = 35
defaultConfig {
applicationId = "com.google.firebase.fiamquickstart"
minSdk = 21
targetSdk = 35
versionCode = 1
versionName = "1.0"
multiDexEnabled = true
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
getByName("release") {
isMinifyEnabled = false
proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlinOptions {
jvmTarget = "17"
}
buildFeatures {
viewBinding = true
}
lint {
warning.add("InvalidPackage")
// TODO(thatfiredev): Remove this once
// path_to_url is fixed
disable.add("NotificationPermission")
}
}
dependencies {
implementation(project(":internal:lintchecks"))
implementation(project(":internal:chooserx"))
implementation("com.google.android.material:material:1.12.0")
implementation("androidx.constraintlayout:constraintlayout:2.1.4")
implementation("androidx.multidex:multidex:2.0.1")
// Import the Firebase BoM (see: path_to_url#bom)
implementation(platform("com.google.firebase:firebase-bom:33.1.2"))
// FIAM
implementation("com.google.firebase:firebase-inappmessaging-display")
// The Firebase SDK for Google Analytics is required to use In-App Messaging
// Analytics
implementation("com.google.firebase:firebase-analytics")
implementation("com.google.firebase:firebase-installations:18.0.0")
androidTestImplementation("androidx.test:runner:1.6.2")
androidTestImplementation("androidx.test.espresso:espresso-core:3.6.1")
androidTestImplementation("androidx.test:rules:1.6.1")
androidTestImplementation("androidx.test.uiautomator:uiautomator:2.3.0")
}
```
|
```javascript
runFormatTest(import.meta, ["babel-flow", "babel"]);
```
|
An artificial whitewater course (AWWC) is a site for whitewater canoeing, whitewater kayaking, whitewater racing, whitewater rafting, playboating and slalom canoeing with artificially generated rapids.
Course types
Main types of course:
Flow diversion
These work by diverting a natural river through boulder placement or damming, or by creating new channels next to an existing river, possibly by a weir or power station outflow.
Tidal action
Created in estuaries with large tidal reaches, on a barrage across the river. The barrage is opened during a rising high tide to allow the sea water in, then shut as the tide turns. The water stored above the barrage is then forced through an artificial channel to provide water features.
Pumped
The nature of artificial whitewater courses necessitates the need for a drop in the river, and enough water flow to provide hydraulics. When this isn't possible (often in flat low-lying areas), electric pumps are used to lift and re-circulate the water to the top of the course. The shapes of these courses are commonly circular or U-shaped.
Pumped courses are extremely expensive to run, typically 1-2 megawatts of electrical power are needed to pump 15 cubic metres per second of water down a course with a 5-meter drop in height.
Altered Riverbed
These courses are created in existing natural river channels, but are enhanced with strategic placement of new rocks, boulders, or concrete structures. Some are downstream of river or channel wide dams and therefore have some level of flow optimization, others are subject to seasonal flows.
Olympic whitewater courses
1972 - Augsburg Eiskanal in Augsburg, Germany — flow diversion
1992 - Segre Olympic Park in La Seu d'Urgell, Spain — flow diversion/pumped
1996 - Ocoee Whitewater Center near Copperhill, Tennessee, US — altered riverbed
2000 - Penrith Whitewater Stadium, near Sydney, Australia — pumped
2004 - Hellinikon Olympic Canoe/Kayak Slalom Centre, Athens, Greece — pumped
2008 - Shunyi Olympic Rowing-Canoeing Park, Beijing, China — pumped
2012 - Lee Valley White Water Centre, London, England — pumped
2016 - Deodoro Olympic Whitewater Stadium, Rio de Janeiro, Brazil — pumped
2021 - Kasai Canoe Slalom Centre, Tokyo, Japan — pumped
Other notable courses
Adventure Sports Center International in McHenry, Maryland, US — pumped
Canolfan Tryweryn near Bala, Gwynedd, North Wales — natural flow modifications
Cardington Artificial Slalom Course near Bedford, England — flow diversion
Dickerson Whitewater Course in Dickerson, Maryland, US — pumped
Dutch Water Dreams in Zoetermeer, Netherlands — pumped
Holme Pierrepont in Nottingham, England — flow diversion
U.S. National Whitewater Center, near Charlotte, North Carolina, US — pumped
Nene Whitewater Centre in Northampton, England — pumped
Rutherford Creek in British Columbia, Canada — flow diversion
Tacen Whitewater Course near Ljubljana, Slovenia — flow diversion
Tees Barrage International White Water Course in Stockton-on-Tees, England — converted from tidal to pumped in 2010/2011
Čunovo Water Sports Centre near Čunovo, Slovakia — flow diversion
Canal de aguas bravas, Zaragoza, Aragon, Spain
Wadi Adventure in Al Ain, Abu Dhabi, United Arab Emirates — pumped
Under planning or construction
References
External links
Hydrostadium, constructor of most Olympic whitewater courses.
Wadi Adventure, UAE.
|
Abhishek Halder (born 5 October 1999) is an Indian professional footballer who plays as a midfielder for Mohammedan in the I-League.
Career
Halder began his career as part of the FC Pune City Academy set up. In November 2017, Halder was selected to play for the Indian Arrows, an All India Football Federation-owned team that would consist of India under-20 players to give them playing time. He made his professional debut for the side on 18 December 2017 against Minerva Punjab. He started and played the whole match as Indian Arrows and lost 1–0.
Mohammedan
In December 2021, Mohammedan added Halder to their roster ahead of the season. On 3 March, he made his debut for the club against Aizawl on the league's return after the COVID-19 breakout, in a 2–0 win.
In June 2022, Halder signed a new two-year deal with Mohammedan. He scored his first goal for the club on 21 August against Jamshedpur in the Durand Cup, which ended in a dominating 3–0 win. He played a 1–2 with Marcus Joseph to finish with a volley chipping over the keeper to double the lead.
Career statistics
Club
References
1999 births
Living people
Indian men's footballers
FC Pune City players
Indian Arrows players
Men's association football midfielders
Footballers from West Bengal
I-League players
India men's youth international footballers
Hyderabad FC players
Indian Super League players
I-League 2nd Division players
Mohammedan SC (Kolkata) players
|
Song to a Seagull (also known as Joni Mitchell) is the debut studio album by Canadian singer-songwriter Joni Mitchell. Produced by David Crosby, the album was recorded in early 1968 at Sunset Sound and released in March 1968 by Reprise Records.
Production
The album was recorded at Sunset Sound in Hollywood, California. David Crosby was assigned as producer as part of the deal with Reprise Records, following meeting Mitchell in October 1967. Crosby wanted Mitchell to sound pure and natural, so he asked her to sing into the studio grand piano, and set up extra microphones to capture her voice reverberating off the strings; unfortunately the set-up captured too much ambient noise, resulting in excessive tape hiss, which could only be removed post-production at the cost of the high sounds in the audio range, which gives the album a flat feel.
Mitchell had written songs that were hits for other artists (e.g., "Both Sides Now" and "Chelsea Morning" by Judy Collins and Dave Van Ronk, "Eastern Rain" by Fairport Convention, "Urge for Going" and "The Circle Game" by Tom Rush), but none of those songs were recorded for her debut.
Content
Mitchell has said that "Sisotowbell" stands for "Somehow, in spite of trouble, ours will be ever lasting love".
Record World said of the single "Night in the City" that "The marvelous Joni Mitchell lights up the imagination with this provocative rock."
The album was dedicated to her Grade 7 English teacher, "Mr. Kratzmann, who taught me to love words".
Release
This album was originally released as Joni Mitchell because the LP album covers were printed incorrectly, cutting off part of the Song to a Seagull title (spelled out by birds in flight). The cut-off, as well as the publishers at Reprise Records not noticing that the birds spelled out the album name, caused the eponymous album title.
The two sides of the LP were labelled as Part 1 – "I Came to the City", and Part 2 – "Out of the City and Down to the Seaside".
On April 8, 2021, Rhino Entertainment, the catalog arm of Warner Music Group, announced that a new mix of the album overseen by Mitchell and mixer Matt Lee would be released on June 25, 2021 as part of a special remaster collection comprising the singer's first four albums. Commenting on the quality of the original mix, Mitchell called it "atrocious" and said it "sounded like it was recorded under a Jello bowl". The remastered collection is part of the ongoing Joni Mitchell Archives project.
Track listing
Personnel
Joni Mitchell – guitar, piano, vocals, album cover, banshee
Stephen Stills – bass on "Night in the City"
Lee Keefer – banshee
Technical
David Crosby – producer
Art Crist – engineer
Ed Thrasher – art direction
Charts
Other versions and covers
Cass Elliot covered two songs from the album: "Sisotowbell Lane" and "I Had a King". Elliot sang "I Had a King" "live" on Andy Williams's Kaleidoscope in 1968. Neither song has ever been released on any of Elliot's seven albums. "Sisotowbell Lane" can be found on the CD compilation The Complete Solo Collection – 1968–71, released in 2005.
Judy Collins covered "Michael from Mountains" on her LP Wildflowers, as did Gábor Szabó on his LP 1969. Buffy Sainte-Marie recorded "Song to a Seagull" on her album Fire & Fleet & Candlelight issued in 1967.
References
External links
Joni Mitchell albums
1968 debut albums
Albums produced by David Crosby
Albums recorded at Sunset Sound Recorders
Albums with cover art by Joni Mitchell
Concept albums
Reprise Records albums
|
Rucentra smetanai is a species of beetle in the family Cerambycidae. It was described by Hüdepohl in 1992. It is known from Borneo.
References
Apomecynini
Beetles described in 1992
|
```shell
#!/bin/bash
# T&M Hansson IT AB - 2024, path_to_url
true
SCRIPT_NAME="Firewall"
SCRIPT_EXPLAINER="This script helps setting up a firewall for your NcVM."
# shellcheck source=lib.sh
source /var/scripts/fetch_lib.sh
# Check for errors + debug code and abort if something isn't right
# 1 = ON
# 0 = OFF
DEBUG=0
debug_mode
# Check if root
root_check
# Check if firewall is already enabled
if ! ufw status | grep -q " active"
then
# Ask for installing
install_popup "$SCRIPT_NAME"
else
# Ask for removal or reinstallation
reinstall_remove_menu "$SCRIPT_NAME"
# Removal
ufw disable
ufw --force reset
# Show successful uninstall if applicable
removal_popup "$SCRIPT_NAME"
fi
# Install and enable firewall
if ! is_this_installed ufw
then
DEBIAN_FRONTEND=noninteractive apt-get install ufw -y --no-install-recommends
systemctl enable ufw &>/dev/null
systemctl start ufw &>/dev/null
fi
# SSH
print_text_in_color "$ICyan" "Allow SSH"
ufw allow ssh comment SSH
# Web server
print_text_in_color "$ICyan" "Web server"
ufw allow http comment http
ufw allow https comment https
# UPnP
print_text_in_color "$ICyan" "UPnP"
ufw allow proto udp from 192.168.0.0/16 comment UPnP
# Adminer
print_text_in_color "$ICyan" "Allow Adminer"
ufw allow 9443/tcp comment Adminer
# Netdata
print_text_in_color "$ICyan" "Allow Netdata"
ufw allow 19999/tcp comment 'Netdata TCP'
ufw allow 19999/udp comment 'Netdata UDP'
# Talk (no custom port possible)
print_text_in_color "$ICyan" "Allow Talk"
ufw allow 3478/tcp comment 'Talk TCP'
ufw allow 3478/udp comment 'Talk UDP'
# Webmin
print_text_in_color "$ICyan" "Allow Webmin"
ufw allow 10000/tcp comment Webmin
# RDP
if is_this_installed xrdp
then
print_text_in_color "$ICyan" "Allow RDP"
ufw allow 3389/tcp comment Remotedesktop
fi
# Samba
if is_this_installed samba
then
print_text_in_color "$ICyan" "Allow Samba"
ufw allow samba comment Samba
fi
# Pi-hole
if pihole &>/dev/null
then
print_text_in_color "$ICyan" "Allow Pi-hole"
ufw allow 53/tcp comment 'Pi-hole TCP'
ufw allow 53/udp comment 'Pi-hole UDP'
ufw allow 8094/tcp comment 'Pi-hole Web'
fi
# PiVPN
if pivpn &>/dev/null
then
print_text_in_color "$ICyan" "Allow PiVPN"
ufw allow 51820/udp comment 'PiVPN'
fi
# Plex
if is_docker_running && docker ps -a --format "{{.Names}}" | grep -q "^plex$"
then
print_text_in_color "$ICyan" "Allow Plex"
for port in 32400/tcp 3005/tcp 8324/tcp 32469/tcp 1900/udp 32410/udp 32412/udp 32413/udp 32414/udp
do
ufw allow "$port" comment "Plex $port"
done
fi
# Enable firewall
print_text_in_color "$ICyan" "Enable Firewall"
ufw --force enable
msg_box "The Firewall was configured successfully!"
```
|
```c
/*! @file clacon.c
* \brief Estimates the 1-norm
*
* <pre>
* -- SuperLU routine (version 2.0) --
* Univ. of California Berkeley, Xerox Palo Alto Research Center,
* and Lawrence Berkeley National Lab.
* November 15, 1997
* </pre>
*/
#include <math.h>
#include "slu_Cnames.h"
#include "slu_scomplex.h"
/*! \brief
*
* <pre>
* Purpose
* =======
*
* CLACON estimates the 1-norm of a square matrix A.
* Reverse communication is used for evaluating matrix-vector products.
*
*
* Arguments
* =========
*
* N (input) INT
* The order of the matrix. N >= 1.
*
* V (workspace) COMPLEX PRECISION array, dimension (N)
* On the final return, V = A*W, where EST = norm(V)/norm(W)
* (W is not returned).
*
* X (input/output) COMPLEX PRECISION array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
* A' * X, if KASE=2,
* where A' is the conjugate transpose of A,
* and CLACON must be re-called with all the other parameters
* unchanged.
*
*
* EST (output) FLOAT PRECISION
* An estimate (a lower bound) for norm(A).
*
* KASE (input/output) INT
* On the initial call to CLACON, KASE should be 0.
* On an intermediate return, KASE will be 1 or 2, indicating
* whether X should be overwritten by A * X or A' * X.
* On the final return from CLACON, KASE will again be 0.
*
* Further Details
* ======= =======
*
* Contributed by Nick Higham, University of Manchester.
* Originally named CONEST, dated March 16, 1988.
*
* Reference: N.J. Higham, "FORTRAN codes for estimating the one-norm of
* a real or complex matrix, with applications to condition estimation",
* ACM Trans. Math. Soft., vol. 14, no. 4, pp. 381-396, December 1988.
* =====================================================================
* </pre>
*/
int
clacon_(int *n, complex *v, complex *x, float *est, int *kase)
{
/* Table of constant values */
int c__1 = 1;
complex zero = {0.0, 0.0};
complex one = {1.0, 0.0};
/* System generated locals */
float d__1;
/* Local variables */
static int iter;
static int jump, jlast;
static float altsgn, estold;
static int i, j;
float temp;
float safmin;
extern float slamch_(char *);
extern int icmax1_(int *, complex *, int *);
extern double scsum1_(int *, complex *, int *);
safmin = slamch_("Safe minimum");
if ( *kase == 0 ) {
for (i = 0; i < *n; ++i) {
x[i].r = 1. / (float) (*n);
x[i].i = 0.;
}
*kase = 1;
jump = 1;
return 0;
}
switch (jump) {
case 1: goto L20;
case 2: goto L40;
case 3: goto L70;
case 4: goto L110;
case 5: goto L140;
}
/* ................ ENTRY (JUMP = 1)
FIRST ITERATION. X HAS BEEN OVERWRITTEN BY A*X. */
L20:
if (*n == 1) {
v[0] = x[0];
*est = c_abs(&v[0]);
/* ... QUIT */
goto L150;
}
*est = scsum1_(n, x, &c__1);
for (i = 0; i < *n; ++i) {
d__1 = c_abs(&x[i]);
if (d__1 > safmin) {
d__1 = 1 / d__1;
x[i].r *= d__1;
x[i].i *= d__1;
} else {
x[i] = one;
}
}
*kase = 2;
jump = 2;
return 0;
/* ................ ENTRY (JUMP = 2)
FIRST ITERATION. X HAS BEEN OVERWRITTEN BY TRANSPOSE(A)*X. */
L40:
j = icmax1_(n, &x[0], &c__1);
--j;
iter = 2;
/* MAIN LOOP - ITERATIONS 2,3,...,ITMAX. */
L50:
for (i = 0; i < *n; ++i) x[i] = zero;
x[j] = one;
*kase = 1;
jump = 3;
return 0;
/* ................ ENTRY (JUMP = 3)
X HAS BEEN OVERWRITTEN BY A*X. */
L70:
#ifdef _CRAY
CCOPY(n, x, &c__1, v, &c__1);
#else
ccopy_(n, x, &c__1, v, &c__1);
#endif
estold = *est;
*est = scsum1_(n, v, &c__1);
L90:
/* TEST FOR CYCLING. */
if (*est <= estold) goto L120;
for (i = 0; i < *n; ++i) {
d__1 = c_abs(&x[i]);
if (d__1 > safmin) {
d__1 = 1 / d__1;
x[i].r *= d__1;
x[i].i *= d__1;
} else {
x[i] = one;
}
}
*kase = 2;
jump = 4;
return 0;
/* ................ ENTRY (JUMP = 4)
X HAS BEEN OVERWRITTEN BY TRANDPOSE(A)*X. */
L110:
jlast = j;
j = icmax1_(n, &x[0], &c__1);
--j;
if (x[jlast].r != (d__1 = x[j].r, fabs(d__1)) && iter < 5) {
++iter;
goto L50;
}
/* ITERATION COMPLETE. FINAL STAGE. */
L120:
altsgn = 1.;
for (i = 1; i <= *n; ++i) {
x[i-1].r = altsgn * ((float)(i - 1) / (float)(*n - 1) + 1.);
x[i-1].i = 0.;
altsgn = -altsgn;
}
*kase = 1;
jump = 5;
return 0;
/* ................ ENTRY (JUMP = 5)
X HAS BEEN OVERWRITTEN BY A*X. */
L140:
temp = scsum1_(n, x, &c__1) / (float)(*n * 3) * 2.;
if (temp > *est) {
#ifdef _CRAY
CCOPY(n, &x[0], &c__1, &v[0], &c__1);
#else
ccopy_(n, &x[0], &c__1, &v[0], &c__1);
#endif
*est = temp;
}
L150:
*kase = 0;
return 0;
} /* clacon_ */
```
|
```python
#
#
# 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.
# ==============================================================================
"""Reads data from a large unlabeled corpus."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import tensorflow as tf
from base import embeddings
from corpus_processing import example
from corpus_processing import minibatching
class UnlabeledDataReader(object):
def __init__(self, config, starting_file=0, starting_line=0, one_pass=False):
self.config = config
self.current_file = starting_file
self.current_line = starting_line
self._one_pass = one_pass
def endless_minibatches(self):
for examples in self.get_unlabeled_examples():
d = minibatching.Dataset(self.config, examples, 'unlabeled')
for mb in d.get_minibatches(self.config.train_batch_size):
yield mb
def _make_examples(self, sentences):
word_vocab = embeddings.get_word_vocab(self.config)
char_vocab = embeddings.get_char_vocab()
return [
example.Example(sentence, word_vocab, char_vocab)
for sentence in sentences
]
def get_unlabeled_examples(self):
lines = []
for words in self.get_unlabeled_sentences():
lines.append(words)
if len(lines) >= 10000:
yield self._make_examples(lines)
lines = []
def get_unlabeled_sentences(self):
while True:
file_ids_and_names = sorted([
(int(fname.split('-')[1].replace('.txt', '')), fname) for fname in
tf.gfile.ListDirectory(self.config.unsupervised_data)])
for fid, fname in file_ids_and_names:
if fid < self.current_file:
continue
self.current_file = fid
self.current_line = 0
with tf.gfile.FastGFile(os.path.join(self.config.unsupervised_data,
fname), 'r') as f:
for i, line in enumerate(f):
if i < self.current_line:
continue
self.current_line = i
words = line.strip().split()
if len(words) < self.config.max_sentence_length:
yield words
self.current_file = 0
self.current_line = 0
if self._one_pass:
break
```
|
Edgar Molinos (born 28 August 1971) is a Guamanian weightlifter. He competed in the men's middleweight event at the 1992 Summer Olympics.
References
1971 births
Living people
Guamanian male weightlifters
Olympic weightlifters for Guam
Weightlifters at the 1992 Summer Olympics
Place of birth missing (living people)
|
```javascript
var convert = require('./convert'),
func = convert('assignAll', require('../assign'));
func.placeholder = require('./placeholder');
module.exports = func;
```
|
```python
FACES = [
(0, 1, 0),
(0, -1, 0),
(-1, 0, 0),
(1, 0, 0),
(0, 0, 1),
(0, 0, -1),
]
class Area:
def __init__(self):
# A mapping from position to the texture of the block at that position.
# This defines all the blocks that are currently in the world.
self.blocks = {}
def get_blocks(self):
return self.blocks
def add_block(self, coords, block):
"""
Add a block element to blocks list
Parameters
----------
coords
block
Returns
-------
"""
if coords in self.blocks:
self.remove_block(coords)
self.blocks[coords] = block
def remove_block(self, coords):
"""Remove the block at the given `coords`.
Parameters
----------
coords : tuple of len 3
The (x, y, z) position of the block to remove.
"""
del self.blocks[coords]
def get_block(self, coords):
"""get the block at the given `position`. This method assumes the
block has already been added with add_block()
Parameters
----------
coords : tuple of len 3
The (x, y, z) position of the block to show.
"""
return self.blocks[coords] if self.blocks[coords] else None
def exposed(self, position):
"""Returns False is given `position` is surrounded on all 6 sides by
blocks, True otherwise.
Parameters
----------
position
Returns
-------
"""
x, y, z = position
for dx, dy, dz in FACES:
if (x + dx, y + dy, z + dz) not in self.blocks:
return True
return False
def get_neighbors(self, position):
"""Check all blocks surrounding `position` and ensure their visual
state is current. This means hiding blocks that are not exposed and
ensuring that all exposed blocks are shown. Usually used after a block
is added or removed.
"""
x, y, z = position
neighbors = {
'show': list(),
'hide': list()
}
for dx, dy, dz in FACES:
key = (x + dx, y + dy, z + dz)
if key not in self.blocks:
continue
if self.exposed(key):
neighbors['show'].append({
'coords': key,
'block': self.get_block(key)
})
else:
neighbors['hide'].append({
'coords': key
})
return neighbors
```
|
One Day in the Future () is a 2010 Turkish comedy film, directed by Boğaçhan Dündar, featuring Hayrettin Karaoğuz as a man who is shown his unrealised future by two angels after committing suicide. The film went on general release across the country on .
Plot
Tolga (Hayrettin Karaoğuz), having struggled with bad luck all his life, believes he is a total loser and the unluckiest man in the whole world. Following an unsuccessful presentation of his new project at work, he is fired. Believing he has ruined his last chance to win over the love of his life (Hande Subaşı), he commits suicide. After he dies, he is met by two angels (Rasim Öztekin and Arda Kural), who, as a punishment, show Tolga scenes from how his life would have been in the future if he had not committed suicide.
Cast
Hayrettin Karaoğuz as Tolga
Hande Subaşı as Ebru
Rasim Öztekin as Canal
Arda Kural as Felek
Neco as Timur
Işın Karaca as Filiz
Murat Serezli as Salim
Bektaş Erdoğan as Metin
Hümeyra Aydoğdu as Berna
Yeşim Dalgıçer as Rüya
Release
The film opened across Turkey on at number six in the box office chart with an opening weekend gross of $135,914.
Reception
Box office
The movie has made a total gross of $296,103.
References
External links
Gelecekten Bir Gün official website (Turkish)
Gelecekten Bir Gün at Beyazperde (Turkish)
2010 films
2010 comedy films
Films about suicide
Films set in Turkey
2010s fantasy comedy films
Turkish fantasy comedy films
2010s Turkish-language films
|
```yaml
# Thanks for downloading ViaVersion
# Ensure you look through all these options
# If you need help:
# Discord - path_to_url
# Docs - path_to_url
#
#----------------------------------------------------------#
# GLOBAL OPTIONS #
#----------------------------------------------------------#
#
# Should ViaVersion check for updates?
check-for-updates: true
# Send the supported versions with the Status (Ping) response packet
send-supported-versions: false
# Easier to configure alternative to 'block-protocols'. Uses readable version strings with possible '<' and '>' prefixes.
# An example to block 1.16.4, everything below 1.16, as well as everything above 1.17.1 would be: ["<1.16", "1.16.4", ">1.17.1"]
# You can use both this and the block-protocols option at the same time as well.
block-versions: []
# Block specific Minecraft protocol version numbers.
# List of all Minecraft protocol versions: path_to_url or use a generator: path_to_url
block-protocols: []
# Change the blocked disconnect message
block-disconnect-msg: "You are using an unsupported Minecraft version!"
# If you use ProtocolLib, we can't reload without kicking the players.
# (We don't suggest using reload either, use a plugin manager)
# You can customize the message we kick people with if you use ProtocolLib here.
reload-disconnect-msg: "Server reload, please rejoin!"
# We warn when there's an error converting item and block data over versions, should we suppress these? (Only suggested if spamming)
suppress-conversion-warnings: false
#
#----------------------------------------------------------#
# VELOCITY OPTIONS #
#----------------------------------------------------------#
#
# Velocity allows you to have different server versions inside.
# Instead of you entering all the versions of these servers, we can ping them.
#
# What interval would you like us to ping at? (in seconds)
# Use -1 to disable.
velocity-ping-interval: 60
# If the above is enabled, should we save the info to the config (in the section below)
velocity-ping-save: true
# To get a server's protocol, ViaVersion will do the following:
# Look for the server in the following section, then look for the last ping if velocity-ping is enabled
# otherwise use default.
#
# The format for the following is:
# servername: protocolversion
# You can find protocol ids on path_to_url
# It will fall back to the default option if none found.
velocity-servers: {}
#
#----------------------------------------------------------#
# GLOBAL PACKET LIMITER #
#----------------------------------------------------------#
# THIS FEATURE IS DISABLED ON 1.17.1+ PAPER SERVERS, SINCE IT HAS A BETTER PACKET-LIMITER INBUILT
#
# Packets Per Second (PPS) limiter (Use -1 on max-pps and tracking-period to disable)
# Clients by default send around 20-90 packets per second.
#
# What is the maximum per second a client can send (Use %pps to display their pps)
# Use -1 to disable.
max-pps: 800
max-pps-kick-msg: "You are sending too many packets!"
#
# We can also kick them if over a period they send over a threshold a certain amount of times.
#
# Period to track (in seconds)
# Use -1 to disable.
tracking-period: 6
# How many packets per second count as a warning?
tracking-warning-pps: 120
# How many warnings over the interval can we have
# This can never be higher than "tracking-period"?
tracking-max-warnings: 4
# The kick message sent if the user hits the max packets per second.
tracking-max-kick-msg: "You are sending too many packets, :("
#
#----------------------------------------------------------#
# MULTIPLE VERSIONS OPTIONS #
#----------------------------------------------------------#
#
# Whether to make sure ViaVersion's UserConnection object is already available in the PlayerJoinEvent.
# You may disable this for faster startup/join time if you are 100% sure no plugin requires this.
register-userconnections-on-join: true
# Should we enable our hologram patch?
# If they're in the wrong place, enable this
hologram-patch: false
# This is the offset, should work as default when enabled.
hologram-y: -0.96
# Should we disable piston animation for 1.11/1.11.1 clients?
# In some cases, when firing lots of pistons, it crashes them.
piston-animation-patch: false
# Should we fix nbt for 1.12 and above clients in chat messages (causes invalid item)
chat-nbt-fix: true
# Experimental - Should we fix shift quick move action for 1.12 clients (causes shift + double click not to work when moving items) (only works on 1.8-1.11.2 bukkit based servers)
quick-move-action-fix: false
# Should we use prefix for team color on 1.13 and above clients?
team-colour-fix: true
# 1.13 introduced new auto complete which can trigger "Kicked for spamming" for servers older than 1.13, the following option will disable it completely.
disable-1_13-auto-complete: false
# The following option will delay the tab complete request in x ticks if greater than 0, if other tab-complete is received, the previous is cancelled
1_13-tab-complete-delay: 0
# For 1.13 clients the smallest (1 layer) snow doesn't have collisions, this will send these as 2 snowlayers for 1.13+ clients to prevent them bugging through them
fix-low-snow-collision: false
# Infested blocks are instantly breakable for 1.13+ clients, resulting in them being unable to break them on sub 1.13 servers. This remaps them to their normal stone variants
fix-infested-block-breaking: true
# In 1.14 the client page limit has been upped to 100 (from 50). Some anti-exploit plugins ban when clients go higher than 50. This option cuts edited books to 50 pages.
truncate-1_14-books: false
# This prevents clients using 1.9-1.13 on 1.8 servers from receiving no knockback/having velocity bugs whilst sneaking under a block.
change-1_9-hitbox: false
# Similar to the above, but for 1.14+ players on 1.8-1.13 servers.
# WARNING: This gives 1.14+ players the ability to sneak under blocks, that players under that version cannot (sneaking in places that are only 1.5 blocks high)!
# Another thing to remember is that those players might be missed by projectiles and other hits directed at the very top of their head whilst sneaking.
change-1_14-hitbox: false
# Fixes 1.14+ clients on sub 1.14 servers having a light value of 0 for non-full blocks.
fix-non-full-blocklight: true
# Fixes walk animation not shown when health is set to Float.NaN
fix-1_14-health-nan: true
# Should 1.15+ clients respawn instantly / without showing a death screen?
use-1_15-instant-respawn: false
#
# Enable serverside block-connections for 1.13+ clients - all the options in this section are built around this option
serverside-blockconnections: true
# Sets the method for the block connections (world for highly experimental (USE AT OWN RISK) world-level or packet for packet-level)
blockconnection-method: packet
# When activated, only the most important blocks are stored in the blockstorage. (fences, glass panes etc. won't connect to solid blocks)
reduce-blockstorage-memory: false
# When activated with serverside-blockconnections, flower parts with blocks above will be sent as stems
# Useful for lobbyservers where users can't build and those stems are used decoratively
flowerstem-when-block-above: false
# Vines that are not connected to blocks will be mapped to air, else 1.13+ would still be able to climb up on them.
vine-climb-fix: false
#
# Ignores incoming plugin channel messages of 1.16+ clients with channel names longer than 32 characters.
# CraftBukkit had this limit hardcoded until 1.16, so we have to assume any server/proxy might have this arbitrary check present.
ignore-long-1_16-channel-names: true
#
# Force 1.17+ client to accept the server resource pack; they will automatically disconnect if they decline.
forced-use-1_17-resource-pack: false
# The message to be displayed at the prompt when the 1.17+ client receives the server resource pack.
resource-pack-1_17-prompt: ''
#
# Caches light until chunks are unloaded to allow later chunk update packets as opposed to instantly uncaching when the first chunk data is sent.
# Only disable this if you know what you are doing.
cache-1_17-light: true
#
# Force-update 1.19.4+ player's inventory when they try to swap armor in a pre-occupied slot.
armor-toggle-fix: true
#
# Get the world names which should be returned for each vanilla dimension
map-1_16-world-names:
overworld: "minecraft:overworld"
nether: "minecraft:the_nether"
end: "minecraft:the_end"
#
# If disabled, tamed cats will be displayed as ocelots to 1.14+ clients on 1.13 servers. Otherwise, ocelots (tamed and untamed) will be displayed as cats.
translate-ocelot-to-cat: false
#
# Determines the value sent to 1.19+ clients on join if currently not accessible by ViaVersion.
# It is not recommended to fake this value if your server is running 1.19 or later, as 1.20.5 have stricter chat handling and may get kicked otherwise.
enforce-secure-chat: false
#
# Handles items with invalid count values (higher than max stack size) on 1.20.3 servers.
handle-invalid-item-count: false
#
#----------------------------------------------------------#
# 1.9+ CLIENTS ON 1.8 SERVERS OPTIONS #
#----------------------------------------------------------#
#
# No collide options, these allow you to configure how collision works.
# Do you want us to prevent collision?
prevent-collision: true
# If the above is true, should we automatically team players until you do?
auto-team: true
# When enabled if certain entity data can't be read, we won't tell you about it
suppress-metadata-errors: false
# When enabled, 1.9+ will be able to block by using shields
shield-blocking: true
# If this setting is active, the main hand is used instead of the off-hand to trigger the blocking of the player.
# With the main hand, the blocking starts way faster.
# (Requires "show-shield-when-sword-in-hand" to be disabled)
no-delay-shield-blocking: false
# If this setting is active, the shield will appear immediately for 1.9+ when you hold a sword in your main hand.
# The shield disappears when you switch to another item.
# (Requires "shield-blocking" to be enabled)
show-shield-when-sword-in-hand: false
# Enable player tick simulation, this fixes eating, drinking, nether portals.
simulate-pt: true
# Should we use nms player to simulate packets, (may fix anti-cheat issues)
nms-player-ticking: true
# Should we patch boss bars so they work? (Default: true, disable if you're having issues)
bossbar-patch: true
# If your boss bar flickers on 1.9+, set this to 'true'. It will keep all boss bars on 100% (not recommended)
bossbar-anti-flicker: false
# This will show the new effect indicator in the top-right corner for 1.9+ players.
use-new-effect-indicator: true
# Show the new death messages for 1.9+ on the death screen
use-new-deathmessages: true
# Should we cache our items, this will prevent the server from being lagged out, however, the cost is a constant task caching items
item-cache: true
# Should we replace extended pistons to fix 1.10.1 (Only on chunk loading)?
replace-pistons: false
# What id should we replace with, default is air. (careful of players getting stuck standing on them)
replacement-piston-id: 0
# Fix 1.9+ clients not rendering the far away chunks and improve chunk rendering when moving fast (Increases network usage and decreases client fps slightly)
chunk-border-fix: false
# Allows 1.9+ left-handedness (main hand) on 1.8 servers
left-handed-handling: true
# Tries to cancel block break/place sounds sent by 1.8 servers to 1.9+ clients to prevent them from playing twice
cancel-block-sounds: true
```
|
```go
package errors
import (
"bytes"
"fmt"
"io/ioutil"
"runtime"
"strings"
)
// A StackFrame contains all necessary information about to generate a line
// in a callstack.
type StackFrame struct {
// The path to the file containing this ProgramCounter
File string
// The LineNumber in that file
LineNumber int
// The Name of the function that contains this ProgramCounter
Name string
// The Package that contains this function
Package string
// The underlying ProgramCounter
ProgramCounter uintptr
}
// NewStackFrame popoulates a stack frame object from the program counter.
func NewStackFrame(pc uintptr) (frame StackFrame) {
frame = StackFrame{ProgramCounter: pc}
if frame.Func() == nil {
return
}
frame.Package, frame.Name = packageAndName(frame.Func())
// pc -1 because the program counters we use are usually return addresses,
// and we want to show the line that corresponds to the function call
frame.File, frame.LineNumber = frame.Func().FileLine(pc - 1)
return
}
// Func returns the function that contained this frame.
func (frame *StackFrame) Func() *runtime.Func {
if frame.ProgramCounter == 0 {
return nil
}
return runtime.FuncForPC(frame.ProgramCounter)
}
// String returns the stackframe formatted in the same way as go does
// in runtime/debug.Stack()
func (frame *StackFrame) String() string {
str := fmt.Sprintf("%s:%d (0x%x)\n", frame.File, frame.LineNumber, frame.ProgramCounter)
source, err := frame.SourceLine()
if err != nil {
return str
}
return str + fmt.Sprintf("\t%s: %s\n", frame.Name, source)
}
// SourceLine gets the line of code (from File and Line) of the original source if possible.
func (frame *StackFrame) SourceLine() (string, error) {
data, err := ioutil.ReadFile(frame.File)
if err != nil {
return "", New(err)
}
lines := bytes.Split(data, []byte{'\n'})
if frame.LineNumber <= 0 || frame.LineNumber >= len(lines) {
return "???", nil
}
// -1 because line-numbers are 1 based, but our array is 0 based
return string(bytes.Trim(lines[frame.LineNumber-1], " \t")), nil
}
func packageAndName(fn *runtime.Func) (string, string) {
name := fn.Name()
pkg := ""
// The name includes the path name to the package, which is unnecessary
// since the file name is already included. Plus, it has center dots.
// That is, we see
// runtime/debug.*Tptrmethod
// and want
// *T.ptrmethod
// Since the package path might contains dots (e.g. code.google.com/...),
// we first remove the path prefix if there is one.
if lastslash := strings.LastIndex(name, "/"); lastslash >= 0 {
pkg += name[:lastslash] + "/"
name = name[lastslash+1:]
}
if period := strings.Index(name, "."); period >= 0 {
pkg += name[:period]
name = name[period+1:]
}
name = strings.Replace(name, "", ".", -1)
return pkg, name
}
```
|
The 2022 Crèdit Andorrà Open was a professional tennis tournament played on indoor hard courts. It was the first edition of the tournament which is also part of the 2022 WTA 125 tournaments, offering a total of $115,000 in prize money. It took place at the Poliesportiu d'Andorra in Andorra la Vella, the capital city of the principality of Andorra between 28 November and 4 December 2022. It was the first ever WTA affiliated tennis tournament to be held in Andorra.
Champions
Singles
Alycia Parks def. Rebecca Peterson 6–1, 6–4
Doubles
Cristina Bucșa / Weronika Falkowska def. Angelina Gabueva / Anastasia Zakharova 7–6(7–4), 6–1
Singles entrants
Seeds
1 Rankings are as of 21 November 2022.
Other entrants
The following players received a wildcard into the singles main draw:
Alina Charaeva
Georgina García Pérez
Sabine Lisicki
Nina Stojanović
Zhang Shuai
The following players received entry into the singles main draw through protected ranking:
Bibiane Schoofs
Yanina Wickmayer
Withdrawals
Before the tournament
Elina Avanesyan → replaced by Jessika Ponchet
Elisabetta Cocciaretto → replaced by Rebecca Peterson
Olga Danilović → replaced by Joanne Züger
Vitalia Diatchenko → replaced by Lina Glushko
Magdalena Fręch → replaced by Anastasia Zakharova
Léolia Jeanjean → replaced by Weronika Falkowska
Elizabeth Mandlik → replaced by Kateryna Baindl
Rebeka Masarova → replaced by Carole Monnet
Kristina Mladenovic → replaced by Sophie Chang
Nuria Párrizas Díaz → replaced by Bibiane Schoofs
Diane Parry → replaced by Katrina Scott
Kamilla Rakhimova → replaced by Jaqueline Cristian
Moyuka Uchijima → replaced by Yanina Wickmayer
Markéta Vondroušová → replaced by Nigina Abduraimova
Wang Xinyu → replaced by Ana Konjuh
Doubles entrants
Seeds
1 Rankings as of 21 November 2022.
Other entrants
The following pair received a wildcard into the doubles main draw:
Georgina García Pérez / Victoria Jiménez Kasintseva
References
External links
Official website
2022 WTA 125 tournaments
2022 in Andorran sport
November 2022 sports events in Europe
December 2022 sports events in Europe
|
```yaml
models:
- columns:
- name: id
tests:
- unique
- not_null
- relationships:
field: id
to: ref('node_0')
name: node_1105
version: 2
```
|
```xml
<vector xmlns:android="path_to_url"
android:width="20dp"
android:height="20dp"
android:viewportWidth="20"
android:viewportHeight="20">
<path
android:fillColor="@color/gray20"
android:pathData="M10,1C5.2,0.9 1.1,4.7 1,9.5C1,9.7 1,9.8 1,10c-0.1,4.8 3.7,8.9 8.5,9c0.2,0 0.3,0 0.5,0c4.8,0.1 8.9,-3.7 9,-8.5c0,-0.2 0,-0.3 0,-0.5c0.1,-4.8 -3.7,-8.9 -8.5,-9C10.3,1 10.2,1 10,1zM12.8,6.8c0.8,0.1 1.3,0.8 1.2,1.6c0.1,0.8 -0.5,1.5 -1.2,1.6c-0.8,-0.1 -1.3,-0.8 -1.2,-1.6C11.4,7.6 12,6.9 12.8,6.8zM7.2,6.8C8,6.9 8.6,7.6 8.5,8.4C8.6,9.2 8,9.9 7.2,10C6.5,9.9 5.9,9.2 6,8.4C5.9,7.6 6.5,6.9 7.2,6.8zM14.6,13.2c-1.9,2.5 -5.5,3.1 -8.1,1.1c-0.4,-0.3 -0.8,-0.7 -1.1,-1.1c-0.2,-0.3 -0.2,-0.8 0.2,-1.1s0.8,-0.2 1.1,0.2c1.4,1.9 4.1,2.2 6,0.8c0.3,-0.2 0.6,-0.5 0.8,-0.8c0.2,-0.3 0.7,-0.4 1.1,-0.2S14.9,12.9 14.6,13.2z"/>
</vector>
```
|
Qaleh Juq (, also Romanized as Qal‘eh Jūq) is a village in Chaybasar-e Shomali Rural District, Bazargan District, Maku County, West Azerbaijan Province, Iran. At the 2006 census, its population was 42, in 7 families.
References
Populated places in Maku County
|
Pyramidobacter is a gram-negative genus of bacteria from the family of Synergistaceae. Pyramidobacter piscolens has been isolated from the human mouth.
See also
List of bacterial orders
List of bacteria genera
References
Synergistota
Bacteria genera
Monotypic bacteria genera
|
Mirashi is both a given name and a surname. Notable people with the name include:
Mirashi Buwa (1883–1966), Indian classical singer
Vasudev Vishnu Mirashi (1893–1985), Sanskrit scholar and Indologist
Pal Mirashi (1925–2001), Albanian footballer
See also
Miras
|
The designation B.II was used for two completely unrelated aircraft produced by Fokker:
The Fokker M.10s flown by Austria-Hungary during World War I (named B.II by the Austro-Hungarian military)
A biplane flying boat flown by the Dutch Navy in the 1920s (named B.II by Fokker)
|
Flinton Creek is a creek in the Moira River and Lake Ontario drainage basins in Hastings and Lennox and Addington Counties in Ontario, Canada.
Course
Flinton Creek begins at an unnamed lake in Addington Highlands, Lennox and Addington County, about west southwest of the community of Flinton Corners, at an elevation of . It travels west, passes under Ontario Highway 41, heads southwest to the east of the community of Flinton, and reaches its mouth at the Skootamatta River just over the border into Hastings County. The Skootamatta River flows via the Moira River into the Bay of Quinte on Lake Ontario at Belleville.
References
Rivers of Hastings County
Rivers of Lennox and Addington County
|
```shell
Using tags for version control
Make your log output pretty
Search by commit message keyword
`master` and `origin` aren't special
Remote repositories: fetching and pushing
```
|
```go
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Transport code.
package http2
import (
"bufio"
"bytes"
"compress/gzip"
"context"
"crypto/rand"
"crypto/tls"
"errors"
"fmt"
"io"
"io/fs"
"log"
"math"
mathrand "math/rand"
"net"
"net/http"
"net/http/httptrace"
"net/textproto"
"os"
"sort"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"golang.org/x/net/http/httpguts"
"golang.org/x/net/http2/hpack"
"golang.org/x/net/idna"
)
const (
// transportDefaultConnFlow is how many connection-level flow control
// tokens we give the server at start-up, past the default 64k.
transportDefaultConnFlow = 1 << 30
// transportDefaultStreamFlow is how many stream-level flow
// control tokens we announce to the peer, and how many bytes
// we buffer per stream.
transportDefaultStreamFlow = 4 << 20
defaultUserAgent = "Go-http-client/2.0"
// initialMaxConcurrentStreams is a connections maxConcurrentStreams until
// it's received servers initial SETTINGS frame, which corresponds with the
// spec's minimum recommended value.
initialMaxConcurrentStreams = 100
// defaultMaxConcurrentStreams is a connections default maxConcurrentStreams
// if the server doesn't include one in its initial SETTINGS frame.
defaultMaxConcurrentStreams = 1000
)
// Transport is an HTTP/2 Transport.
//
// A Transport internally caches connections to servers. It is safe
// for concurrent use by multiple goroutines.
type Transport struct {
// DialTLSContext specifies an optional dial function with context for
// creating TLS connections for requests.
//
// If DialTLSContext and DialTLS is nil, tls.Dial is used.
//
// If the returned net.Conn has a ConnectionState method like tls.Conn,
// it will be used to set http.Response.TLS.
DialTLSContext func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error)
// DialTLS specifies an optional dial function for creating
// TLS connections for requests.
//
// If DialTLSContext and DialTLS is nil, tls.Dial is used.
//
// Deprecated: Use DialTLSContext instead, which allows the transport
// to cancel dials as soon as they are no longer needed.
// If both are set, DialTLSContext takes priority.
DialTLS func(network, addr string, cfg *tls.Config) (net.Conn, error)
// TLSClientConfig specifies the TLS configuration to use with
// tls.Client. If nil, the default configuration is used.
TLSClientConfig *tls.Config
// ConnPool optionally specifies an alternate connection pool to use.
// If nil, the default is used.
ConnPool ClientConnPool
// DisableCompression, if true, prevents the Transport from
// requesting compression with an "Accept-Encoding: gzip"
// request header when the Request contains no existing
// Accept-Encoding value. If the Transport requests gzip on
// its own and gets a gzipped response, it's transparently
// decoded in the Response.Body. However, if the user
// explicitly requested gzip it is not automatically
// uncompressed.
DisableCompression bool
// AllowHTTP, if true, permits HTTP/2 requests using the insecure,
// plain-text "http" scheme. Note that this does not enable h2c support.
AllowHTTP bool
// MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to
// send in the initial settings frame. It is how many bytes
// of response headers are allowed. Unlike the http2 spec, zero here
// means to use a default limit (currently 10MB). If you actually
// want to advertise an unlimited value to the peer, Transport
// interprets the highest possible value here (0xffffffff or 1<<32-1)
// to mean no limit.
MaxHeaderListSize uint32
// MaxReadFrameSize is the http2 SETTINGS_MAX_FRAME_SIZE to send in the
// initial settings frame. It is the size in bytes of the largest frame
// payload that the sender is willing to receive. If 0, no setting is
// sent, and the value is provided by the peer, which should be 16384
// according to the spec:
// path_to_url#section-6.5.2.
// Values are bounded in the range 16k to 16M.
MaxReadFrameSize uint32
// MaxDecoderHeaderTableSize optionally specifies the http2
// SETTINGS_HEADER_TABLE_SIZE to send in the initial settings frame. It
// informs the remote endpoint of the maximum size of the header compression
// table used to decode header blocks, in octets. If zero, the default value
// of 4096 is used.
MaxDecoderHeaderTableSize uint32
// MaxEncoderHeaderTableSize optionally specifies an upper limit for the
// header compression table used for encoding request headers. Received
// SETTINGS_HEADER_TABLE_SIZE settings are capped at this limit. If zero,
// the default value of 4096 is used.
MaxEncoderHeaderTableSize uint32
// StrictMaxConcurrentStreams controls whether the server's
// SETTINGS_MAX_CONCURRENT_STREAMS should be respected
// globally. If false, new TCP connections are created to the
// server as needed to keep each under the per-connection
// SETTINGS_MAX_CONCURRENT_STREAMS limit. If true, the
// server's SETTINGS_MAX_CONCURRENT_STREAMS is interpreted as
// a global limit and callers of RoundTrip block when needed,
// waiting for their turn.
StrictMaxConcurrentStreams bool
// ReadIdleTimeout is the timeout after which a health check using ping
// frame will be carried out if no frame is received on the connection.
// Note that a ping response will is considered a received frame, so if
// there is no other traffic on the connection, the health check will
// be performed every ReadIdleTimeout interval.
// If zero, no health check is performed.
ReadIdleTimeout time.Duration
// PingTimeout is the timeout after which the connection will be closed
// if a response to Ping is not received.
// Defaults to 15s.
PingTimeout time.Duration
// WriteByteTimeout is the timeout after which the connection will be
// closed no data can be written to it. The timeout begins when data is
// available to write, and is extended whenever any bytes are written.
WriteByteTimeout time.Duration
// CountError, if non-nil, is called on HTTP/2 transport errors.
// It's intended to increment a metric for monitoring, such
// as an expvar or Prometheus metric.
// The errType consists of only ASCII word characters.
CountError func(errType string)
// t1, if non-nil, is the standard library Transport using
// this transport. Its settings are used (but not its
// RoundTrip method, etc).
t1 *http.Transport
connPoolOnce sync.Once
connPoolOrDef ClientConnPool // non-nil version of ConnPool
}
func (t *Transport) maxHeaderListSize() uint32 {
if t.MaxHeaderListSize == 0 {
return 10 << 20
}
if t.MaxHeaderListSize == 0xffffffff {
return 0
}
return t.MaxHeaderListSize
}
func (t *Transport) maxFrameReadSize() uint32 {
if t.MaxReadFrameSize == 0 {
return 0 // use the default provided by the peer
}
if t.MaxReadFrameSize < minMaxFrameSize {
return minMaxFrameSize
}
if t.MaxReadFrameSize > maxFrameSize {
return maxFrameSize
}
return t.MaxReadFrameSize
}
func (t *Transport) disableCompression() bool {
return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression)
}
func (t *Transport) pingTimeout() time.Duration {
if t.PingTimeout == 0 {
return 15 * time.Second
}
return t.PingTimeout
}
// ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2.
// It returns an error if t1 has already been HTTP/2-enabled.
//
// Use ConfigureTransports instead to configure the HTTP/2 Transport.
func ConfigureTransport(t1 *http.Transport) error {
_, err := ConfigureTransports(t1)
return err
}
// ConfigureTransports configures a net/http HTTP/1 Transport to use HTTP/2.
// It returns a new HTTP/2 Transport for further configuration.
// It returns an error if t1 has already been HTTP/2-enabled.
func ConfigureTransports(t1 *http.Transport) (*Transport, error) {
return configureTransports(t1)
}
func configureTransports(t1 *http.Transport) (*Transport, error) {
connPool := new(clientConnPool)
t2 := &Transport{
ConnPool: noDialClientConnPool{connPool},
t1: t1,
}
connPool.t = t2
if err := registerHTTPSProtocol(t1, noDialH2RoundTripper{t2}); err != nil {
return nil, err
}
if t1.TLSClientConfig == nil {
t1.TLSClientConfig = new(tls.Config)
}
if !strSliceContains(t1.TLSClientConfig.NextProtos, "h2") {
t1.TLSClientConfig.NextProtos = append([]string{"h2"}, t1.TLSClientConfig.NextProtos...)
}
if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") {
t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1")
}
upgradeFn := func(authority string, c *tls.Conn) http.RoundTripper {
addr := authorityAddr("https", authority)
if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil {
go c.Close()
return erringRoundTripper{err}
} else if !used {
// Turns out we don't need this c.
// For example, two goroutines made requests to the same host
// at the same time, both kicking off TCP dials. (since protocol
// was unknown)
go c.Close()
}
return t2
}
if m := t1.TLSNextProto; len(m) == 0 {
t1.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{
"h2": upgradeFn,
}
} else {
m["h2"] = upgradeFn
}
return t2, nil
}
func (t *Transport) connPool() ClientConnPool {
t.connPoolOnce.Do(t.initConnPool)
return t.connPoolOrDef
}
func (t *Transport) initConnPool() {
if t.ConnPool != nil {
t.connPoolOrDef = t.ConnPool
} else {
t.connPoolOrDef = &clientConnPool{t: t}
}
}
// ClientConn is the state of a single HTTP/2 client connection to an
// HTTP/2 server.
type ClientConn struct {
t *Transport
tconn net.Conn // usually *tls.Conn, except specialized impls
tconnClosed bool
tlsState *tls.ConnectionState // nil only for specialized impls
reused uint32 // whether conn is being reused; atomic
singleUse bool // whether being used for a single http.Request
getConnCalled bool // used by clientConnPool
// readLoop goroutine fields:
readerDone chan struct{} // closed on error
readerErr error // set before readerDone is closed
idleTimeout time.Duration // or 0 for never
idleTimer *time.Timer
mu sync.Mutex // guards following
cond *sync.Cond // hold mu; broadcast on flow/closed changes
flow outflow // our conn-level flow control quota (cs.outflow is per stream)
inflow inflow // peer's conn-level flow control
doNotReuse bool // whether conn is marked to not be reused for any future requests
closing bool
closed bool
seenSettings bool // true if we've seen a settings frame, false otherwise
wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back
goAway *GoAwayFrame // if non-nil, the GoAwayFrame we received
goAwayDebug string // goAway frame's debug data, retained as a string
streams map[uint32]*clientStream // client-initiated
streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip
nextStreamID uint32
pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams
pings map[[8]byte]chan struct{} // in flight ping data to notification channel
br *bufio.Reader
lastActive time.Time
lastIdle time.Time // time last idle
// Settings from peer: (also guarded by wmu)
maxFrameSize uint32
maxConcurrentStreams uint32
peerMaxHeaderListSize uint64
peerMaxHeaderTableSize uint32
initialWindowSize uint32
// reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests.
// Write to reqHeaderMu to lock it, read from it to unlock.
// Lock reqmu BEFORE mu or wmu.
reqHeaderMu chan struct{}
// wmu is held while writing.
// Acquire BEFORE mu when holding both, to avoid blocking mu on network writes.
// Only acquire both at the same time when changing peer settings.
wmu sync.Mutex
bw *bufio.Writer
fr *Framer
werr error // first write error that has occurred
hbuf bytes.Buffer // HPACK encoder writes into this
henc *hpack.Encoder
}
// clientStream is the state for a single HTTP/2 stream. One of these
// is created for each Transport.RoundTrip call.
type clientStream struct {
cc *ClientConn
// Fields of Request that we may access even after the response body is closed.
ctx context.Context
reqCancel <-chan struct{}
trace *httptrace.ClientTrace // or nil
ID uint32
bufPipe pipe // buffered pipe with the flow-controlled response payload
requestedGzip bool
isHead bool
abortOnce sync.Once
abort chan struct{} // closed to signal stream should end immediately
abortErr error // set if abort is closed
peerClosed chan struct{} // closed when the peer sends an END_STREAM flag
donec chan struct{} // closed after the stream is in the closed state
on100 chan struct{} // buffered; written to if a 100 is received
respHeaderRecv chan struct{} // closed when headers are received
res *http.Response // set if respHeaderRecv is closed
flow outflow // guarded by cc.mu
inflow inflow // guarded by cc.mu
bytesRemain int64 // -1 means unknown; owned by transportResponseBody.Read
readErr error // sticky read error; owned by transportResponseBody.Read
reqBody io.ReadCloser
reqBodyContentLength int64 // -1 means unknown
reqBodyClosed chan struct{} // guarded by cc.mu; non-nil on Close, closed when done
// owned by writeRequest:
sentEndStream bool // sent an END_STREAM flag to the peer
sentHeaders bool
// owned by clientConnReadLoop:
firstByte bool // got the first response byte
pastHeaders bool // got first MetaHeadersFrame (actual headers)
pastTrailers bool // got optional second MetaHeadersFrame (trailers)
num1xx uint8 // number of 1xx responses seen
readClosed bool // peer sent an END_STREAM flag
readAborted bool // read loop reset the stream
trailer http.Header // accumulated trailers
resTrailer *http.Header // client's Response.Trailer
}
var got1xxFuncForTests func(int, textproto.MIMEHeader) error
// get1xxTraceFunc returns the value of request's httptrace.ClientTrace.Got1xxResponse func,
// if any. It returns nil if not set or if the Go version is too old.
func (cs *clientStream) get1xxTraceFunc() func(int, textproto.MIMEHeader) error {
if fn := got1xxFuncForTests; fn != nil {
return fn
}
return traceGot1xxResponseFunc(cs.trace)
}
func (cs *clientStream) abortStream(err error) {
cs.cc.mu.Lock()
defer cs.cc.mu.Unlock()
cs.abortStreamLocked(err)
}
func (cs *clientStream) abortStreamLocked(err error) {
cs.abortOnce.Do(func() {
cs.abortErr = err
close(cs.abort)
})
if cs.reqBody != nil {
cs.closeReqBodyLocked()
}
// TODO(dneil): Clean up tests where cs.cc.cond is nil.
if cs.cc.cond != nil {
// Wake up writeRequestBody if it is waiting on flow control.
cs.cc.cond.Broadcast()
}
}
func (cs *clientStream) abortRequestBodyWrite() {
cc := cs.cc
cc.mu.Lock()
defer cc.mu.Unlock()
if cs.reqBody != nil && cs.reqBodyClosed == nil {
cs.closeReqBodyLocked()
cc.cond.Broadcast()
}
}
func (cs *clientStream) closeReqBodyLocked() {
if cs.reqBodyClosed != nil {
return
}
cs.reqBodyClosed = make(chan struct{})
reqBodyClosed := cs.reqBodyClosed
go func() {
cs.reqBody.Close()
close(reqBodyClosed)
}()
}
type stickyErrWriter struct {
conn net.Conn
timeout time.Duration
err *error
}
func (sew stickyErrWriter) Write(p []byte) (n int, err error) {
if *sew.err != nil {
return 0, *sew.err
}
for {
if sew.timeout != 0 {
sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout))
}
nn, err := sew.conn.Write(p[n:])
n += nn
if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) {
// Keep extending the deadline so long as we're making progress.
continue
}
if sew.timeout != 0 {
sew.conn.SetWriteDeadline(time.Time{})
}
*sew.err = err
return n, err
}
}
// noCachedConnError is the concrete type of ErrNoCachedConn, which
// needs to be detected by net/http regardless of whether it's its
// bundled version (in h2_bundle.go with a rewritten type name) or
// from a user's x/net/http2. As such, as it has a unique method name
// (IsHTTP2NoCachedConnError) that net/http sniffs for via func
// isNoCachedConnError.
type noCachedConnError struct{}
func (noCachedConnError) IsHTTP2NoCachedConnError() {}
func (noCachedConnError) Error() string { return "http2: no cached connection was available" }
// isNoCachedConnError reports whether err is of type noCachedConnError
// or its equivalent renamed type in net/http2's h2_bundle.go. Both types
// may coexist in the same running program.
func isNoCachedConnError(err error) bool {
_, ok := err.(interface{ IsHTTP2NoCachedConnError() })
return ok
}
var ErrNoCachedConn error = noCachedConnError{}
// RoundTripOpt are options for the Transport.RoundTripOpt method.
type RoundTripOpt struct {
// OnlyCachedConn controls whether RoundTripOpt may
// create a new TCP connection. If set true and
// no cached connection is available, RoundTripOpt
// will return ErrNoCachedConn.
OnlyCachedConn bool
}
func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
return t.RoundTripOpt(req, RoundTripOpt{})
}
// authorityAddr returns a given authority (a host/IP, or host:port / ip:port)
// and returns a host:port. The port 443 is added if needed.
func authorityAddr(scheme string, authority string) (addr string) {
host, port, err := net.SplitHostPort(authority)
if err != nil { // authority didn't have a port
port = "443"
if scheme == "http" {
port = "80"
}
host = authority
}
if a, err := idna.ToASCII(host); err == nil {
host = a
}
// IPv6 address literal, without a port:
if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") {
return host + ":" + port
}
return net.JoinHostPort(host, port)
}
var retryBackoffHook func(time.Duration) *time.Timer
func backoffNewTimer(d time.Duration) *time.Timer {
if retryBackoffHook != nil {
return retryBackoffHook(d)
}
return time.NewTimer(d)
}
// RoundTripOpt is like RoundTrip, but takes options.
func (t *Transport) RoundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) {
return nil, errors.New("http2: unsupported scheme")
}
addr := authorityAddr(req.URL.Scheme, req.URL.Host)
for retry := 0; ; retry++ {
cc, err := t.connPool().GetClientConn(req, addr)
if err != nil {
t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err)
return nil, err
}
reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1)
traceGotConn(req, cc, reused)
res, err := cc.RoundTrip(req)
if err != nil && retry <= 6 {
if req, err = shouldRetryRequest(req, err); err == nil {
// After the first retry, do exponential backoff with 10% jitter.
if retry == 0 {
t.vlogf("RoundTrip retrying after failure: %v", err)
continue
}
backoff := float64(uint(1) << (uint(retry) - 1))
backoff += backoff * (0.1 * mathrand.Float64())
d := time.Second * time.Duration(backoff)
timer := backoffNewTimer(d)
select {
case <-timer.C:
t.vlogf("RoundTrip retrying after failure: %v", err)
continue
case <-req.Context().Done():
timer.Stop()
err = req.Context().Err()
}
}
}
if err != nil {
t.vlogf("RoundTrip failure: %v", err)
return nil, err
}
return res, nil
}
}
// CloseIdleConnections closes any connections which were previously
// connected from previous requests but are now sitting idle.
// It does not interrupt any connections currently in use.
func (t *Transport) CloseIdleConnections() {
if cp, ok := t.connPool().(clientConnPoolIdleCloser); ok {
cp.closeIdleConnections()
}
}
var (
errClientConnClosed = errors.New("http2: client conn is closed")
errClientConnUnusable = errors.New("http2: client conn not usable")
errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
)
// shouldRetryRequest is called by RoundTrip when a request fails to get
// response headers. It is always called with a non-nil error.
// It returns either a request to retry (either the same request, or a
// modified clone), or an error if the request can't be replayed.
func shouldRetryRequest(req *http.Request, err error) (*http.Request, error) {
if !canRetryError(err) {
return nil, err
}
// If the Body is nil (or http.NoBody), it's safe to reuse
// this request and its Body.
if req.Body == nil || req.Body == http.NoBody {
return req, nil
}
// If the request body can be reset back to its original
// state via the optional req.GetBody, do that.
if req.GetBody != nil {
body, err := req.GetBody()
if err != nil {
return nil, err
}
newReq := *req
newReq.Body = body
return &newReq, nil
}
// The Request.Body can't reset back to the beginning, but we
// don't seem to have started to read from it yet, so reuse
// the request directly.
if err == errClientConnUnusable {
return req, nil
}
return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
}
func canRetryError(err error) bool {
if err == errClientConnUnusable || err == errClientConnGotGoAway {
return true
}
if se, ok := err.(StreamError); ok {
if se.Code == ErrCodeProtocol && se.Cause == errFromPeer {
// See golang/go#47635, golang/go#42777
return true
}
return se.Code == ErrCodeRefusedStream
}
return false
}
func (t *Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*ClientConn, error) {
host, _, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
tconn, err := t.dialTLS(ctx, "tcp", addr, t.newTLSConfig(host))
if err != nil {
return nil, err
}
return t.newClientConn(tconn, singleUse)
}
func (t *Transport) newTLSConfig(host string) *tls.Config {
cfg := new(tls.Config)
if t.TLSClientConfig != nil {
*cfg = *t.TLSClientConfig.Clone()
}
if !strSliceContains(cfg.NextProtos, NextProtoTLS) {
cfg.NextProtos = append([]string{NextProtoTLS}, cfg.NextProtos...)
}
if cfg.ServerName == "" {
cfg.ServerName = host
}
return cfg
}
func (t *Transport) dialTLS(ctx context.Context, network, addr string, tlsCfg *tls.Config) (net.Conn, error) {
if t.DialTLSContext != nil {
return t.DialTLSContext(ctx, network, addr, tlsCfg)
} else if t.DialTLS != nil {
return t.DialTLS(network, addr, tlsCfg)
}
tlsCn, err := t.dialTLSWithContext(ctx, network, addr, tlsCfg)
if err != nil {
return nil, err
}
state := tlsCn.ConnectionState()
if p := state.NegotiatedProtocol; p != NextProtoTLS {
return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS)
}
if !state.NegotiatedProtocolIsMutual {
return nil, errors.New("http2: could not negotiate protocol mutually")
}
return tlsCn, nil
}
// disableKeepAlives reports whether connections should be closed as
// soon as possible after handling the first request.
func (t *Transport) disableKeepAlives() bool {
return t.t1 != nil && t.t1.DisableKeepAlives
}
func (t *Transport) expectContinueTimeout() time.Duration {
if t.t1 == nil {
return 0
}
return t.t1.ExpectContinueTimeout
}
func (t *Transport) maxDecoderHeaderTableSize() uint32 {
if v := t.MaxDecoderHeaderTableSize; v > 0 {
return v
}
return initialHeaderTableSize
}
func (t *Transport) maxEncoderHeaderTableSize() uint32 {
if v := t.MaxEncoderHeaderTableSize; v > 0 {
return v
}
return initialHeaderTableSize
}
func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) {
return t.newClientConn(c, t.disableKeepAlives())
}
func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) {
cc := &ClientConn{
t: t,
tconn: c,
readerDone: make(chan struct{}),
nextStreamID: 1,
maxFrameSize: 16 << 10, // spec default
initialWindowSize: 65535, // spec default
maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings.
peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead.
streams: make(map[uint32]*clientStream),
singleUse: singleUse,
wantSettingsAck: true,
pings: make(map[[8]byte]chan struct{}),
reqHeaderMu: make(chan struct{}, 1),
}
if d := t.idleConnTimeout(); d != 0 {
cc.idleTimeout = d
cc.idleTimer = time.AfterFunc(d, cc.onIdleTimeout)
}
if VerboseLogs {
t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr())
}
cc.cond = sync.NewCond(&cc.mu)
cc.flow.add(int32(initialWindowSize))
// TODO: adjust this writer size to account for frame size +
// MTU + crypto/tls record padding.
cc.bw = bufio.NewWriter(stickyErrWriter{
conn: c,
timeout: t.WriteByteTimeout,
err: &cc.werr,
})
cc.br = bufio.NewReader(c)
cc.fr = NewFramer(cc.bw, cc.br)
if t.maxFrameReadSize() != 0 {
cc.fr.SetMaxReadFrameSize(t.maxFrameReadSize())
}
if t.CountError != nil {
cc.fr.countError = t.CountError
}
maxHeaderTableSize := t.maxDecoderHeaderTableSize()
cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil)
cc.fr.MaxHeaderListSize = t.maxHeaderListSize()
cc.henc = hpack.NewEncoder(&cc.hbuf)
cc.henc.SetMaxDynamicTableSizeLimit(t.maxEncoderHeaderTableSize())
cc.peerMaxHeaderTableSize = initialHeaderTableSize
if t.AllowHTTP {
cc.nextStreamID = 3
}
if cs, ok := c.(connectionStater); ok {
state := cs.ConnectionState()
cc.tlsState = &state
}
initialSettings := []Setting{
{ID: SettingEnablePush, Val: 0},
{ID: SettingInitialWindowSize, Val: transportDefaultStreamFlow},
}
if max := t.maxFrameReadSize(); max != 0 {
initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: max})
}
if max := t.maxHeaderListSize(); max != 0 {
initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max})
}
if maxHeaderTableSize != initialHeaderTableSize {
initialSettings = append(initialSettings, Setting{ID: SettingHeaderTableSize, Val: maxHeaderTableSize})
}
cc.bw.Write(clientPreface)
cc.fr.WriteSettings(initialSettings...)
cc.fr.WriteWindowUpdate(0, transportDefaultConnFlow)
cc.inflow.init(transportDefaultConnFlow + initialWindowSize)
cc.bw.Flush()
if cc.werr != nil {
cc.Close()
return nil, cc.werr
}
go cc.readLoop()
return cc, nil
}
func (cc *ClientConn) healthCheck() {
pingTimeout := cc.t.pingTimeout()
// We don't need to periodically ping in the health check, because the readLoop of ClientConn will
// trigger the healthCheck again if there is no frame received.
ctx, cancel := context.WithTimeout(context.Background(), pingTimeout)
defer cancel()
cc.vlogf("http2: Transport sending health check")
err := cc.Ping(ctx)
if err != nil {
cc.vlogf("http2: Transport health check failure: %v", err)
cc.closeForLostPing()
} else {
cc.vlogf("http2: Transport health check success")
}
}
// SetDoNotReuse marks cc as not reusable for future HTTP requests.
func (cc *ClientConn) SetDoNotReuse() {
cc.mu.Lock()
defer cc.mu.Unlock()
cc.doNotReuse = true
}
func (cc *ClientConn) setGoAway(f *GoAwayFrame) {
cc.mu.Lock()
defer cc.mu.Unlock()
old := cc.goAway
cc.goAway = f
// Merge the previous and current GoAway error frames.
if cc.goAwayDebug == "" {
cc.goAwayDebug = string(f.DebugData())
}
if old != nil && old.ErrCode != ErrCodeNo {
cc.goAway.ErrCode = old.ErrCode
}
last := f.LastStreamID
for streamID, cs := range cc.streams {
if streamID > last {
cs.abortStreamLocked(errClientConnGotGoAway)
}
}
}
// CanTakeNewRequest reports whether the connection can take a new request,
// meaning it has not been closed or received or sent a GOAWAY.
//
// If the caller is going to immediately make a new request on this
// connection, use ReserveNewRequest instead.
func (cc *ClientConn) CanTakeNewRequest() bool {
cc.mu.Lock()
defer cc.mu.Unlock()
return cc.canTakeNewRequestLocked()
}
// ReserveNewRequest is like CanTakeNewRequest but also reserves a
// concurrent stream in cc. The reservation is decremented on the
// next call to RoundTrip.
func (cc *ClientConn) ReserveNewRequest() bool {
cc.mu.Lock()
defer cc.mu.Unlock()
if st := cc.idleStateLocked(); !st.canTakeNewRequest {
return false
}
cc.streamsReserved++
return true
}
// ClientConnState describes the state of a ClientConn.
type ClientConnState struct {
// Closed is whether the connection is closed.
Closed bool
// Closing is whether the connection is in the process of
// closing. It may be closing due to shutdown, being a
// single-use connection, being marked as DoNotReuse, or
// having received a GOAWAY frame.
Closing bool
// StreamsActive is how many streams are active.
StreamsActive int
// StreamsReserved is how many streams have been reserved via
// ClientConn.ReserveNewRequest.
StreamsReserved int
// StreamsPending is how many requests have been sent in excess
// of the peer's advertised MaxConcurrentStreams setting and
// are waiting for other streams to complete.
StreamsPending int
// MaxConcurrentStreams is how many concurrent streams the
// peer advertised as acceptable. Zero means no SETTINGS
// frame has been received yet.
MaxConcurrentStreams uint32
// LastIdle, if non-zero, is when the connection last
// transitioned to idle state.
LastIdle time.Time
}
// State returns a snapshot of cc's state.
func (cc *ClientConn) State() ClientConnState {
cc.wmu.Lock()
maxConcurrent := cc.maxConcurrentStreams
if !cc.seenSettings {
maxConcurrent = 0
}
cc.wmu.Unlock()
cc.mu.Lock()
defer cc.mu.Unlock()
return ClientConnState{
Closed: cc.closed,
Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil,
StreamsActive: len(cc.streams),
StreamsReserved: cc.streamsReserved,
StreamsPending: cc.pendingRequests,
LastIdle: cc.lastIdle,
MaxConcurrentStreams: maxConcurrent,
}
}
// clientConnIdleState describes the suitability of a client
// connection to initiate a new RoundTrip request.
type clientConnIdleState struct {
canTakeNewRequest bool
}
func (cc *ClientConn) idleState() clientConnIdleState {
cc.mu.Lock()
defer cc.mu.Unlock()
return cc.idleStateLocked()
}
func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) {
if cc.singleUse && cc.nextStreamID > 1 {
return
}
var maxConcurrentOkay bool
if cc.t.StrictMaxConcurrentStreams {
// We'll tell the caller we can take a new request to
// prevent the caller from dialing a new TCP
// connection, but then we'll block later before
// writing it.
maxConcurrentOkay = true
} else {
maxConcurrentOkay = int64(len(cc.streams)+cc.streamsReserved+1) <= int64(cc.maxConcurrentStreams)
}
st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay &&
!cc.doNotReuse &&
int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 &&
!cc.tooIdleLocked()
return
}
func (cc *ClientConn) canTakeNewRequestLocked() bool {
st := cc.idleStateLocked()
return st.canTakeNewRequest
}
// tooIdleLocked reports whether this connection has been been sitting idle
// for too much wall time.
func (cc *ClientConn) tooIdleLocked() bool {
// The Round(0) strips the monontonic clock reading so the
// times are compared based on their wall time. We don't want
// to reuse a connection that's been sitting idle during
// VM/laptop suspend if monotonic time was also frozen.
return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout
}
// onIdleTimeout is called from a time.AfterFunc goroutine. It will
// only be called when we're idle, but because we're coming from a new
// goroutine, there could be a new request coming in at the same time,
// so this simply calls the synchronized closeIfIdle to shut down this
// connection. The timer could just call closeIfIdle, but this is more
// clear.
func (cc *ClientConn) onIdleTimeout() {
cc.closeIfIdle()
}
func (cc *ClientConn) closeConn() {
t := time.AfterFunc(250*time.Millisecond, cc.forceCloseConn)
defer t.Stop()
cc.tconn.Close()
}
// A tls.Conn.Close can hang for a long time if the peer is unresponsive.
// Try to shut it down more aggressively.
func (cc *ClientConn) forceCloseConn() {
tc, ok := cc.tconn.(*tls.Conn)
if !ok {
return
}
if nc := tlsUnderlyingConn(tc); nc != nil {
nc.Close()
}
}
func (cc *ClientConn) closeIfIdle() {
cc.mu.Lock()
if len(cc.streams) > 0 || cc.streamsReserved > 0 {
cc.mu.Unlock()
return
}
cc.closed = true
nextID := cc.nextStreamID
// TODO: do clients send GOAWAY too? maybe? Just Close:
cc.mu.Unlock()
if VerboseLogs {
cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, nextID-2)
}
cc.closeConn()
}
func (cc *ClientConn) isDoNotReuseAndIdle() bool {
cc.mu.Lock()
defer cc.mu.Unlock()
return cc.doNotReuse && len(cc.streams) == 0
}
var shutdownEnterWaitStateHook = func() {}
// Shutdown gracefully closes the client connection, waiting for running streams to complete.
func (cc *ClientConn) Shutdown(ctx context.Context) error {
if err := cc.sendGoAway(); err != nil {
return err
}
// Wait for all in-flight streams to complete or connection to close
done := make(chan struct{})
cancelled := false // guarded by cc.mu
go func() {
cc.mu.Lock()
defer cc.mu.Unlock()
for {
if len(cc.streams) == 0 || cc.closed {
cc.closed = true
close(done)
break
}
if cancelled {
break
}
cc.cond.Wait()
}
}()
shutdownEnterWaitStateHook()
select {
case <-done:
cc.closeConn()
return nil
case <-ctx.Done():
cc.mu.Lock()
// Free the goroutine above
cancelled = true
cc.cond.Broadcast()
cc.mu.Unlock()
return ctx.Err()
}
}
func (cc *ClientConn) sendGoAway() error {
cc.mu.Lock()
closing := cc.closing
cc.closing = true
maxStreamID := cc.nextStreamID
cc.mu.Unlock()
if closing {
// GOAWAY sent already
return nil
}
cc.wmu.Lock()
defer cc.wmu.Unlock()
// Send a graceful shutdown frame to server
if err := cc.fr.WriteGoAway(maxStreamID, ErrCodeNo, nil); err != nil {
return err
}
if err := cc.bw.Flush(); err != nil {
return err
}
// Prevent new requests
return nil
}
// closes the client connection immediately. In-flight requests are interrupted.
// err is sent to streams.
func (cc *ClientConn) closeForError(err error) {
cc.mu.Lock()
cc.closed = true
for _, cs := range cc.streams {
cs.abortStreamLocked(err)
}
cc.cond.Broadcast()
cc.mu.Unlock()
cc.closeConn()
}
// Close closes the client connection immediately.
//
// In-flight requests are interrupted. For a graceful shutdown, use Shutdown instead.
func (cc *ClientConn) Close() error {
err := errors.New("http2: client connection force closed via ClientConn.Close")
cc.closeForError(err)
return nil
}
// closes the client connection immediately. In-flight requests are interrupted.
func (cc *ClientConn) closeForLostPing() {
err := errors.New("http2: client connection lost")
if f := cc.t.CountError; f != nil {
f("conn_close_lost_ping")
}
cc.closeForError(err)
}
// errRequestCanceled is a copy of net/http's errRequestCanceled because it's not
// exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests.
var errRequestCanceled = errors.New("net/http: request canceled")
func commaSeparatedTrailers(req *http.Request) (string, error) {
keys := make([]string, 0, len(req.Trailer))
for k := range req.Trailer {
k = canonicalHeader(k)
switch k {
case "Transfer-Encoding", "Trailer", "Content-Length":
return "", fmt.Errorf("invalid Trailer key %q", k)
}
keys = append(keys, k)
}
if len(keys) > 0 {
sort.Strings(keys)
return strings.Join(keys, ","), nil
}
return "", nil
}
func (cc *ClientConn) responseHeaderTimeout() time.Duration {
if cc.t.t1 != nil {
return cc.t.t1.ResponseHeaderTimeout
}
// No way to do this (yet?) with just an http2.Transport. Probably
// no need. Request.Cancel this is the new way. We only need to support
// this for compatibility with the old http.Transport fields when
// we're doing transparent http2.
return 0
}
// checkConnHeaders checks whether req has any invalid connection-level headers.
// per RFC 7540 section 8.1.2.2: Connection-Specific Header Fields.
// Certain headers are special-cased as okay but not transmitted later.
func checkConnHeaders(req *http.Request) error {
if v := req.Header.Get("Upgrade"); v != "" {
return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
}
if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && vv[0] != "chunked") {
return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
}
if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !asciiEqualFold(vv[0], "close") && !asciiEqualFold(vv[0], "keep-alive")) {
return fmt.Errorf("http2: invalid Connection request header: %q", vv)
}
return nil
}
// actualContentLength returns a sanitized version of
// req.ContentLength, where 0 actually means zero (not unknown) and -1
// means unknown.
func actualContentLength(req *http.Request) int64 {
if req.Body == nil || req.Body == http.NoBody {
return 0
}
if req.ContentLength != 0 {
return req.ContentLength
}
return -1
}
func (cc *ClientConn) decrStreamReservations() {
cc.mu.Lock()
defer cc.mu.Unlock()
cc.decrStreamReservationsLocked()
}
func (cc *ClientConn) decrStreamReservationsLocked() {
if cc.streamsReserved > 0 {
cc.streamsReserved--
}
}
func (cc *ClientConn) RoundTrip(req *http.Request) (*http.Response, error) {
ctx := req.Context()
cs := &clientStream{
cc: cc,
ctx: ctx,
reqCancel: req.Cancel,
isHead: req.Method == "HEAD",
reqBody: req.Body,
reqBodyContentLength: actualContentLength(req),
trace: httptrace.ContextClientTrace(ctx),
peerClosed: make(chan struct{}),
abort: make(chan struct{}),
respHeaderRecv: make(chan struct{}),
donec: make(chan struct{}),
}
go cs.doRequest(req)
waitDone := func() error {
select {
case <-cs.donec:
return nil
case <-ctx.Done():
return ctx.Err()
case <-cs.reqCancel:
return errRequestCanceled
}
}
handleResponseHeaders := func() (*http.Response, error) {
res := cs.res
if res.StatusCode > 299 {
// On error or status code 3xx, 4xx, 5xx, etc abort any
// ongoing write, assuming that the server doesn't care
// about our request body. If the server replied with 1xx or
// 2xx, however, then assume the server DOES potentially
// want our body (e.g. full-duplex streaming:
// golang.org/issue/13444). If it turns out the server
// doesn't, they'll RST_STREAM us soon enough. This is a
// heuristic to avoid adding knobs to Transport. Hopefully
// we can keep it.
cs.abortRequestBodyWrite()
}
res.Request = req
res.TLS = cc.tlsState
if res.Body == noBody && actualContentLength(req) == 0 {
// If there isn't a request or response body still being
// written, then wait for the stream to be closed before
// RoundTrip returns.
if err := waitDone(); err != nil {
return nil, err
}
}
return res, nil
}
for {
select {
case <-cs.respHeaderRecv:
return handleResponseHeaders()
case <-cs.abort:
select {
case <-cs.respHeaderRecv:
// If both cs.respHeaderRecv and cs.abort are signaling,
// pick respHeaderRecv. The server probably wrote the
// response and immediately reset the stream.
// golang.org/issue/49645
return handleResponseHeaders()
default:
waitDone()
return nil, cs.abortErr
}
case <-ctx.Done():
err := ctx.Err()
cs.abortStream(err)
return nil, err
case <-cs.reqCancel:
cs.abortStream(errRequestCanceled)
return nil, errRequestCanceled
}
}
}
// doRequest runs for the duration of the request lifetime.
//
// It sends the request and performs post-request cleanup (closing Request.Body, etc.).
func (cs *clientStream) doRequest(req *http.Request) {
err := cs.writeRequest(req)
cs.cleanupWriteRequest(err)
}
// writeRequest sends a request.
//
// It returns nil after the request is written, the response read,
// and the request stream is half-closed by the peer.
//
// It returns non-nil if the request ends otherwise.
// If the returned error is StreamError, the error Code may be used in resetting the stream.
func (cs *clientStream) writeRequest(req *http.Request) (err error) {
cc := cs.cc
ctx := cs.ctx
if err := checkConnHeaders(req); err != nil {
return err
}
// Acquire the new-request lock by writing to reqHeaderMu.
// This lock guards the critical section covering allocating a new stream ID
// (requires mu) and creating the stream (requires wmu).
if cc.reqHeaderMu == nil {
panic("RoundTrip on uninitialized ClientConn") // for tests
}
select {
case cc.reqHeaderMu <- struct{}{}:
case <-cs.reqCancel:
return errRequestCanceled
case <-ctx.Done():
return ctx.Err()
}
cc.mu.Lock()
if cc.idleTimer != nil {
cc.idleTimer.Stop()
}
cc.decrStreamReservationsLocked()
if err := cc.awaitOpenSlotForStreamLocked(cs); err != nil {
cc.mu.Unlock()
<-cc.reqHeaderMu
return err
}
cc.addStreamLocked(cs) // assigns stream ID
if isConnectionCloseRequest(req) {
cc.doNotReuse = true
}
cc.mu.Unlock()
// TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
if !cc.t.disableCompression() &&
req.Header.Get("Accept-Encoding") == "" &&
req.Header.Get("Range") == "" &&
!cs.isHead {
// Request gzip only, not deflate. Deflate is ambiguous and
// not as universally supported anyway.
// See: path_to_url#faq39
//
// Note that we don't request this for HEAD requests,
// due to a bug in nginx:
// path_to_url
// path_to_url
//
// We don't request gzip if the request is for a range, since
// auto-decoding a portion of a gzipped document will just fail
// anyway. See path_to_url
cs.requestedGzip = true
}
continueTimeout := cc.t.expectContinueTimeout()
if continueTimeout != 0 {
if !httpguts.HeaderValuesContainsToken(req.Header["Expect"], "100-continue") {
continueTimeout = 0
} else {
cs.on100 = make(chan struct{}, 1)
}
}
// Past this point (where we send request headers), it is possible for
// RoundTrip to return successfully. Since the RoundTrip contract permits
// the caller to "mutate or reuse" the Request after closing the Response's Body,
// we must take care when referencing the Request from here on.
err = cs.encodeAndWriteHeaders(req)
<-cc.reqHeaderMu
if err != nil {
return err
}
hasBody := cs.reqBodyContentLength != 0
if !hasBody {
cs.sentEndStream = true
} else {
if continueTimeout != 0 {
traceWait100Continue(cs.trace)
timer := time.NewTimer(continueTimeout)
select {
case <-timer.C:
err = nil
case <-cs.on100:
err = nil
case <-cs.abort:
err = cs.abortErr
case <-ctx.Done():
err = ctx.Err()
case <-cs.reqCancel:
err = errRequestCanceled
}
timer.Stop()
if err != nil {
traceWroteRequest(cs.trace, err)
return err
}
}
if err = cs.writeRequestBody(req); err != nil {
if err != errStopReqBodyWrite {
traceWroteRequest(cs.trace, err)
return err
}
} else {
cs.sentEndStream = true
}
}
traceWroteRequest(cs.trace, err)
var respHeaderTimer <-chan time.Time
var respHeaderRecv chan struct{}
if d := cc.responseHeaderTimeout(); d != 0 {
timer := time.NewTimer(d)
defer timer.Stop()
respHeaderTimer = timer.C
respHeaderRecv = cs.respHeaderRecv
}
// Wait until the peer half-closes its end of the stream,
// or until the request is aborted (via context, error, or otherwise),
// whichever comes first.
for {
select {
case <-cs.peerClosed:
return nil
case <-respHeaderTimer:
return errTimeout
case <-respHeaderRecv:
respHeaderRecv = nil
respHeaderTimer = nil // keep waiting for END_STREAM
case <-cs.abort:
return cs.abortErr
case <-ctx.Done():
return ctx.Err()
case <-cs.reqCancel:
return errRequestCanceled
}
}
}
func (cs *clientStream) encodeAndWriteHeaders(req *http.Request) error {
cc := cs.cc
ctx := cs.ctx
cc.wmu.Lock()
defer cc.wmu.Unlock()
// If the request was canceled while waiting for cc.mu, just quit.
select {
case <-cs.abort:
return cs.abortErr
case <-ctx.Done():
return ctx.Err()
case <-cs.reqCancel:
return errRequestCanceled
default:
}
// Encode headers.
//
// we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is
// sent by writeRequestBody below, along with any Trailers,
// again in form HEADERS{1}, CONTINUATION{0,})
trailers, err := commaSeparatedTrailers(req)
if err != nil {
return err
}
hasTrailers := trailers != ""
contentLen := actualContentLength(req)
hasBody := contentLen != 0
hdrs, err := cc.encodeHeaders(req, cs.requestedGzip, trailers, contentLen)
if err != nil {
return err
}
// Write the request.
endStream := !hasBody && !hasTrailers
cs.sentHeaders = true
err = cc.writeHeaders(cs.ID, endStream, int(cc.maxFrameSize), hdrs)
traceWroteHeaders(cs.trace)
return err
}
// cleanupWriteRequest performs post-request tasks.
//
// If err (the result of writeRequest) is non-nil and the stream is not closed,
// cleanupWriteRequest will send a reset to the peer.
func (cs *clientStream) cleanupWriteRequest(err error) {
cc := cs.cc
if cs.ID == 0 {
// We were canceled before creating the stream, so return our reservation.
cc.decrStreamReservations()
}
// TODO: write h12Compare test showing whether
// Request.Body is closed by the Transport,
// and in multiple cases: server replies <=299 and >299
// while still writing request body
cc.mu.Lock()
mustCloseBody := false
if cs.reqBody != nil && cs.reqBodyClosed == nil {
mustCloseBody = true
cs.reqBodyClosed = make(chan struct{})
}
bodyClosed := cs.reqBodyClosed
cc.mu.Unlock()
if mustCloseBody {
cs.reqBody.Close()
close(bodyClosed)
}
if bodyClosed != nil {
<-bodyClosed
}
if err != nil && cs.sentEndStream {
// If the connection is closed immediately after the response is read,
// we may be aborted before finishing up here. If the stream was closed
// cleanly on both sides, there is no error.
select {
case <-cs.peerClosed:
err = nil
default:
}
}
if err != nil {
cs.abortStream(err) // possibly redundant, but harmless
if cs.sentHeaders {
if se, ok := err.(StreamError); ok {
if se.Cause != errFromPeer {
cc.writeStreamReset(cs.ID, se.Code, err)
}
} else {
cc.writeStreamReset(cs.ID, ErrCodeCancel, err)
}
}
cs.bufPipe.CloseWithError(err) // no-op if already closed
} else {
if cs.sentHeaders && !cs.sentEndStream {
cc.writeStreamReset(cs.ID, ErrCodeNo, nil)
}
cs.bufPipe.CloseWithError(errRequestCanceled)
}
if cs.ID != 0 {
cc.forgetStreamID(cs.ID)
}
cc.wmu.Lock()
werr := cc.werr
cc.wmu.Unlock()
if werr != nil {
cc.Close()
}
close(cs.donec)
}
// awaitOpenSlotForStreamLocked waits until len(streams) < maxConcurrentStreams.
// Must hold cc.mu.
func (cc *ClientConn) awaitOpenSlotForStreamLocked(cs *clientStream) error {
for {
cc.lastActive = time.Now()
if cc.closed || !cc.canTakeNewRequestLocked() {
return errClientConnUnusable
}
cc.lastIdle = time.Time{}
if int64(len(cc.streams)) < int64(cc.maxConcurrentStreams) {
return nil
}
cc.pendingRequests++
cc.cond.Wait()
cc.pendingRequests--
select {
case <-cs.abort:
return cs.abortErr
default:
}
}
}
// requires cc.wmu be held
func (cc *ClientConn) writeHeaders(streamID uint32, endStream bool, maxFrameSize int, hdrs []byte) error {
first := true // first frame written (HEADERS is first, then CONTINUATION)
for len(hdrs) > 0 && cc.werr == nil {
chunk := hdrs
if len(chunk) > maxFrameSize {
chunk = chunk[:maxFrameSize]
}
hdrs = hdrs[len(chunk):]
endHeaders := len(hdrs) == 0
if first {
cc.fr.WriteHeaders(HeadersFrameParam{
StreamID: streamID,
BlockFragment: chunk,
EndStream: endStream,
EndHeaders: endHeaders,
})
first = false
} else {
cc.fr.WriteContinuation(streamID, endHeaders, chunk)
}
}
cc.bw.Flush()
return cc.werr
}
// internal error values; they don't escape to callers
var (
// abort request body write; don't send cancel
errStopReqBodyWrite = errors.New("http2: aborting request body write")
// abort request body write, but send stream reset of cancel.
errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
errReqBodyTooLong = errors.New("http2: request body larger than specified content length")
)
// frameScratchBufferLen returns the length of a buffer to use for
// outgoing request bodies to read/write to/from.
//
// It returns max(1, min(peer's advertised max frame size,
// Request.ContentLength+1, 512KB)).
func (cs *clientStream) frameScratchBufferLen(maxFrameSize int) int {
const max = 512 << 10
n := int64(maxFrameSize)
if n > max {
n = max
}
if cl := cs.reqBodyContentLength; cl != -1 && cl+1 < n {
// Add an extra byte past the declared content-length to
// give the caller's Request.Body io.Reader a chance to
// give us more bytes than they declared, so we can catch it
// early.
n = cl + 1
}
if n < 1 {
return 1
}
return int(n) // doesn't truncate; max is 512K
}
var bufPool sync.Pool // of *[]byte
func (cs *clientStream) writeRequestBody(req *http.Request) (err error) {
cc := cs.cc
body := cs.reqBody
sentEnd := false // whether we sent the final DATA frame w/ END_STREAM
hasTrailers := req.Trailer != nil
remainLen := cs.reqBodyContentLength
hasContentLen := remainLen != -1
cc.mu.Lock()
maxFrameSize := int(cc.maxFrameSize)
cc.mu.Unlock()
// Scratch buffer for reading into & writing from.
scratchLen := cs.frameScratchBufferLen(maxFrameSize)
var buf []byte
if bp, ok := bufPool.Get().(*[]byte); ok && len(*bp) >= scratchLen {
defer bufPool.Put(bp)
buf = *bp
} else {
buf = make([]byte, scratchLen)
defer bufPool.Put(&buf)
}
var sawEOF bool
for !sawEOF {
n, err := body.Read(buf)
if hasContentLen {
remainLen -= int64(n)
if remainLen == 0 && err == nil {
// The request body's Content-Length was predeclared and
// we just finished reading it all, but the underlying io.Reader
// returned the final chunk with a nil error (which is one of
// the two valid things a Reader can do at EOF). Because we'd prefer
// to send the END_STREAM bit early, double-check that we're actually
// at EOF. Subsequent reads should return (0, EOF) at this point.
// If either value is different, we return an error in one of two ways below.
var scratch [1]byte
var n1 int
n1, err = body.Read(scratch[:])
remainLen -= int64(n1)
}
if remainLen < 0 {
err = errReqBodyTooLong
return err
}
}
if err != nil {
cc.mu.Lock()
bodyClosed := cs.reqBodyClosed != nil
cc.mu.Unlock()
switch {
case bodyClosed:
return errStopReqBodyWrite
case err == io.EOF:
sawEOF = true
err = nil
default:
return err
}
}
remain := buf[:n]
for len(remain) > 0 && err == nil {
var allowed int32
allowed, err = cs.awaitFlowControl(len(remain))
if err != nil {
return err
}
cc.wmu.Lock()
data := remain[:allowed]
remain = remain[allowed:]
sentEnd = sawEOF && len(remain) == 0 && !hasTrailers
err = cc.fr.WriteData(cs.ID, sentEnd, data)
if err == nil {
// TODO(bradfitz): this flush is for latency, not bandwidth.
// Most requests won't need this. Make this opt-in or
// opt-out? Use some heuristic on the body type? Nagel-like
// timers? Based on 'n'? Only last chunk of this for loop,
// unless flow control tokens are low? For now, always.
// If we change this, see comment below.
err = cc.bw.Flush()
}
cc.wmu.Unlock()
}
if err != nil {
return err
}
}
if sentEnd {
// Already sent END_STREAM (which implies we have no
// trailers) and flushed, because currently all
// WriteData frames above get a flush. So we're done.
return nil
}
// Since the RoundTrip contract permits the caller to "mutate or reuse"
// a request after the Response's Body is closed, verify that this hasn't
// happened before accessing the trailers.
cc.mu.Lock()
trailer := req.Trailer
err = cs.abortErr
cc.mu.Unlock()
if err != nil {
return err
}
cc.wmu.Lock()
defer cc.wmu.Unlock()
var trls []byte
if len(trailer) > 0 {
trls, err = cc.encodeTrailers(trailer)
if err != nil {
return err
}
}
// Two ways to send END_STREAM: either with trailers, or
// with an empty DATA frame.
if len(trls) > 0 {
err = cc.writeHeaders(cs.ID, true, maxFrameSize, trls)
} else {
err = cc.fr.WriteData(cs.ID, true, nil)
}
if ferr := cc.bw.Flush(); ferr != nil && err == nil {
err = ferr
}
return err
}
// awaitFlowControl waits for [1, min(maxBytes, cc.cs.maxFrameSize)] flow
// control tokens from the server.
// It returns either the non-zero number of tokens taken or an error
// if the stream is dead.
func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) {
cc := cs.cc
ctx := cs.ctx
cc.mu.Lock()
defer cc.mu.Unlock()
for {
if cc.closed {
return 0, errClientConnClosed
}
if cs.reqBodyClosed != nil {
return 0, errStopReqBodyWrite
}
select {
case <-cs.abort:
return 0, cs.abortErr
case <-ctx.Done():
return 0, ctx.Err()
case <-cs.reqCancel:
return 0, errRequestCanceled
default:
}
if a := cs.flow.available(); a > 0 {
take := a
if int(take) > maxBytes {
take = int32(maxBytes) // can't truncate int; take is int32
}
if take > int32(cc.maxFrameSize) {
take = int32(cc.maxFrameSize)
}
cs.flow.take(take)
return take, nil
}
cc.cond.Wait()
}
}
var errNilRequestURL = errors.New("http2: Request.URI is nil")
// requires cc.wmu be held.
func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) {
cc.hbuf.Reset()
if req.URL == nil {
return nil, errNilRequestURL
}
host := req.Host
if host == "" {
host = req.URL.Host
}
host, err := httpguts.PunycodeHostPort(host)
if err != nil {
return nil, err
}
var path string
if req.Method != "CONNECT" {
path = req.URL.RequestURI()
if !validPseudoPath(path) {
orig := path
path = strings.TrimPrefix(path, req.URL.Scheme+"://"+host)
if !validPseudoPath(path) {
if req.URL.Opaque != "" {
return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
} else {
return nil, fmt.Errorf("invalid request :path %q", orig)
}
}
}
}
// Check for any invalid headers and return an error before we
// potentially pollute our hpack state. (We want to be able to
// continue to reuse the hpack encoder for future requests)
for k, vv := range req.Header {
if !httpguts.ValidHeaderFieldName(k) {
return nil, fmt.Errorf("invalid HTTP header name %q", k)
}
for _, v := range vv {
if !httpguts.ValidHeaderFieldValue(v) {
// Don't include the value in the error, because it may be sensitive.
return nil, fmt.Errorf("invalid HTTP header value for header %q", k)
}
}
}
enumerateHeaders := func(f func(name, value string)) {
// 8.1.2.3 Request Pseudo-Header Fields
// The :path pseudo-header field includes the path and query parts of the
// target URI (the path-absolute production and optionally a '?' character
// followed by the query production (see Sections 3.3 and 3.4 of
// [RFC3986]).
f(":authority", host)
m := req.Method
if m == "" {
m = http.MethodGet
}
f(":method", m)
if req.Method != "CONNECT" {
f(":path", path)
f(":scheme", req.URL.Scheme)
}
if trailers != "" {
f("trailer", trailers)
}
var didUA bool
for k, vv := range req.Header {
if asciiEqualFold(k, "host") || asciiEqualFold(k, "content-length") {
// Host is :authority, already sent.
// Content-Length is automatic, set below.
continue
} else if asciiEqualFold(k, "connection") ||
asciiEqualFold(k, "proxy-connection") ||
asciiEqualFold(k, "transfer-encoding") ||
asciiEqualFold(k, "upgrade") ||
asciiEqualFold(k, "keep-alive") {
// Per 8.1.2.2 Connection-Specific Header
// Fields, don't send connection-specific
// fields. We have already checked if any
// are error-worthy so just ignore the rest.
continue
} else if asciiEqualFold(k, "user-agent") {
// Match Go's http1 behavior: at most one
// User-Agent. If set to nil or empty string,
// then omit it. Otherwise if not mentioned,
// include the default (below).
didUA = true
if len(vv) < 1 {
continue
}
vv = vv[:1]
if vv[0] == "" {
continue
}
} else if asciiEqualFold(k, "cookie") {
// Per 8.1.2.5 To allow for better compression efficiency, the
// Cookie header field MAY be split into separate header fields,
// each with one or more cookie-pairs.
for _, v := range vv {
for {
p := strings.IndexByte(v, ';')
if p < 0 {
break
}
f("cookie", v[:p])
p++
// strip space after semicolon if any.
for p+1 <= len(v) && v[p] == ' ' {
p++
}
v = v[p:]
}
if len(v) > 0 {
f("cookie", v)
}
}
continue
}
for _, v := range vv {
f(k, v)
}
}
if shouldSendReqContentLength(req.Method, contentLength) {
f("content-length", strconv.FormatInt(contentLength, 10))
}
if addGzipHeader {
f("accept-encoding", "gzip")
}
if !didUA {
f("user-agent", defaultUserAgent)
}
}
// Do a first pass over the headers counting bytes to ensure
// we don't exceed cc.peerMaxHeaderListSize. This is done as a
// separate pass before encoding the headers to prevent
// modifying the hpack state.
hlSize := uint64(0)
enumerateHeaders(func(name, value string) {
hf := hpack.HeaderField{Name: name, Value: value}
hlSize += uint64(hf.Size())
})
if hlSize > cc.peerMaxHeaderListSize {
return nil, errRequestHeaderListSize
}
trace := httptrace.ContextClientTrace(req.Context())
traceHeaders := traceHasWroteHeaderField(trace)
// Header list size is ok. Write the headers.
enumerateHeaders(func(name, value string) {
name, ascii := lowerHeader(name)
if !ascii {
// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
// field names have to be ASCII characters (just as in HTTP/1.x).
return
}
cc.writeHeader(name, value)
if traceHeaders {
traceWroteHeaderField(trace, name, value)
}
})
return cc.hbuf.Bytes(), nil
}
// shouldSendReqContentLength reports whether the http2.Transport should send
// a "content-length" request header. This logic is basically a copy of the net/http
// transferWriter.shouldSendContentLength.
// The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
// -1 means unknown.
func shouldSendReqContentLength(method string, contentLength int64) bool {
if contentLength > 0 {
return true
}
if contentLength < 0 {
return false
}
// For zero bodies, whether we send a content-length depends on the method.
// It also kinda doesn't matter for http2 either way, with END_STREAM.
switch method {
case "POST", "PUT", "PATCH":
return true
default:
return false
}
}
// requires cc.wmu be held.
func (cc *ClientConn) encodeTrailers(trailer http.Header) ([]byte, error) {
cc.hbuf.Reset()
hlSize := uint64(0)
for k, vv := range trailer {
for _, v := range vv {
hf := hpack.HeaderField{Name: k, Value: v}
hlSize += uint64(hf.Size())
}
}
if hlSize > cc.peerMaxHeaderListSize {
return nil, errRequestHeaderListSize
}
for k, vv := range trailer {
lowKey, ascii := lowerHeader(k)
if !ascii {
// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
// field names have to be ASCII characters (just as in HTTP/1.x).
continue
}
// Transfer-Encoding, etc.. have already been filtered at the
// start of RoundTrip
for _, v := range vv {
cc.writeHeader(lowKey, v)
}
}
return cc.hbuf.Bytes(), nil
}
func (cc *ClientConn) writeHeader(name, value string) {
if VerboseLogs {
log.Printf("http2: Transport encoding header %q = %q", name, value)
}
cc.henc.WriteField(hpack.HeaderField{Name: name, Value: value})
}
type resAndError struct {
_ incomparable
res *http.Response
err error
}
// requires cc.mu be held.
func (cc *ClientConn) addStreamLocked(cs *clientStream) {
cs.flow.add(int32(cc.initialWindowSize))
cs.flow.setConnFlow(&cc.flow)
cs.inflow.init(transportDefaultStreamFlow)
cs.ID = cc.nextStreamID
cc.nextStreamID += 2
cc.streams[cs.ID] = cs
if cs.ID == 0 {
panic("assigned stream ID 0")
}
}
func (cc *ClientConn) forgetStreamID(id uint32) {
cc.mu.Lock()
slen := len(cc.streams)
delete(cc.streams, id)
if len(cc.streams) != slen-1 {
panic("forgetting unknown stream id")
}
cc.lastActive = time.Now()
if len(cc.streams) == 0 && cc.idleTimer != nil {
cc.idleTimer.Reset(cc.idleTimeout)
cc.lastIdle = time.Now()
}
// Wake up writeRequestBody via clientStream.awaitFlowControl and
// wake up RoundTrip if there is a pending request.
cc.cond.Broadcast()
closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil
if closeOnIdle && cc.streamsReserved == 0 && len(cc.streams) == 0 {
if VerboseLogs {
cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, cc.nextStreamID-2)
}
cc.closed = true
defer cc.closeConn()
}
cc.mu.Unlock()
}
// clientConnReadLoop is the state owned by the clientConn's frame-reading readLoop.
type clientConnReadLoop struct {
_ incomparable
cc *ClientConn
}
// readLoop runs in its own goroutine and reads and dispatches frames.
func (cc *ClientConn) readLoop() {
rl := &clientConnReadLoop{cc: cc}
defer rl.cleanup()
cc.readerErr = rl.run()
if ce, ok := cc.readerErr.(ConnectionError); ok {
cc.wmu.Lock()
cc.fr.WriteGoAway(0, ErrCode(ce), nil)
cc.wmu.Unlock()
}
}
// GoAwayError is returned by the Transport when the server closes the
// TCP connection after sending a GOAWAY frame.
type GoAwayError struct {
LastStreamID uint32
ErrCode ErrCode
DebugData string
}
func (e GoAwayError) Error() string {
return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
e.LastStreamID, e.ErrCode, e.DebugData)
}
func isEOFOrNetReadError(err error) bool {
if err == io.EOF {
return true
}
ne, ok := err.(*net.OpError)
return ok && ne.Op == "read"
}
func (rl *clientConnReadLoop) cleanup() {
cc := rl.cc
cc.t.connPool().MarkDead(cc)
defer cc.closeConn()
defer close(cc.readerDone)
if cc.idleTimer != nil {
cc.idleTimer.Stop()
}
// Close any response bodies if the server closes prematurely.
// TODO: also do this if we've written the headers but not
// gotten a response yet.
err := cc.readerErr
cc.mu.Lock()
if cc.goAway != nil && isEOFOrNetReadError(err) {
err = GoAwayError{
LastStreamID: cc.goAway.LastStreamID,
ErrCode: cc.goAway.ErrCode,
DebugData: cc.goAwayDebug,
}
} else if err == io.EOF {
err = io.ErrUnexpectedEOF
}
cc.closed = true
for _, cs := range cc.streams {
select {
case <-cs.peerClosed:
// The server closed the stream before closing the conn,
// so no need to interrupt it.
default:
cs.abortStreamLocked(err)
}
}
cc.cond.Broadcast()
cc.mu.Unlock()
}
// countReadFrameError calls Transport.CountError with a string
// representing err.
func (cc *ClientConn) countReadFrameError(err error) {
f := cc.t.CountError
if f == nil || err == nil {
return
}
if ce, ok := err.(ConnectionError); ok {
errCode := ErrCode(ce)
f(fmt.Sprintf("read_frame_conn_error_%s", errCode.stringToken()))
return
}
if errors.Is(err, io.EOF) {
f("read_frame_eof")
return
}
if errors.Is(err, io.ErrUnexpectedEOF) {
f("read_frame_unexpected_eof")
return
}
if errors.Is(err, ErrFrameTooLarge) {
f("read_frame_too_large")
return
}
f("read_frame_other")
}
func (rl *clientConnReadLoop) run() error {
cc := rl.cc
gotSettings := false
readIdleTimeout := cc.t.ReadIdleTimeout
var t *time.Timer
if readIdleTimeout != 0 {
t = time.AfterFunc(readIdleTimeout, cc.healthCheck)
defer t.Stop()
}
for {
f, err := cc.fr.ReadFrame()
if t != nil {
t.Reset(readIdleTimeout)
}
if err != nil {
cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err)
}
if se, ok := err.(StreamError); ok {
if cs := rl.streamByID(se.StreamID); cs != nil {
if se.Cause == nil {
se.Cause = cc.fr.errDetail
}
rl.endStreamError(cs, se)
}
continue
} else if err != nil {
cc.countReadFrameError(err)
return err
}
if VerboseLogs {
cc.vlogf("http2: Transport received %s", summarizeFrame(f))
}
if !gotSettings {
if _, ok := f.(*SettingsFrame); !ok {
cc.logf("protocol error: received %T before a SETTINGS frame", f)
return ConnectionError(ErrCodeProtocol)
}
gotSettings = true
}
switch f := f.(type) {
case *MetaHeadersFrame:
err = rl.processHeaders(f)
case *DataFrame:
err = rl.processData(f)
case *GoAwayFrame:
err = rl.processGoAway(f)
case *RSTStreamFrame:
err = rl.processResetStream(f)
case *SettingsFrame:
err = rl.processSettings(f)
case *PushPromiseFrame:
err = rl.processPushPromise(f)
case *WindowUpdateFrame:
err = rl.processWindowUpdate(f)
case *PingFrame:
err = rl.processPing(f)
default:
cc.logf("Transport: unhandled response frame type %T", f)
}
if err != nil {
if VerboseLogs {
cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err)
}
return err
}
}
}
func (rl *clientConnReadLoop) processHeaders(f *MetaHeadersFrame) error {
cs := rl.streamByID(f.StreamID)
if cs == nil {
// We'd get here if we canceled a request while the
// server had its response still in flight. So if this
// was just something we canceled, ignore it.
return nil
}
if cs.readClosed {
rl.endStreamError(cs, StreamError{
StreamID: f.StreamID,
Code: ErrCodeProtocol,
Cause: errors.New("protocol error: headers after END_STREAM"),
})
return nil
}
if !cs.firstByte {
if cs.trace != nil {
// TODO(bradfitz): move first response byte earlier,
// when we first read the 9 byte header, not waiting
// until all the HEADERS+CONTINUATION frames have been
// merged. This works for now.
traceFirstResponseByte(cs.trace)
}
cs.firstByte = true
}
if !cs.pastHeaders {
cs.pastHeaders = true
} else {
return rl.processTrailers(cs, f)
}
res, err := rl.handleResponse(cs, f)
if err != nil {
if _, ok := err.(ConnectionError); ok {
return err
}
// Any other error type is a stream error.
rl.endStreamError(cs, StreamError{
StreamID: f.StreamID,
Code: ErrCodeProtocol,
Cause: err,
})
return nil // return nil from process* funcs to keep conn alive
}
if res == nil {
// (nil, nil) special case. See handleResponse docs.
return nil
}
cs.resTrailer = &res.Trailer
cs.res = res
close(cs.respHeaderRecv)
if f.StreamEnded() {
rl.endStream(cs)
}
return nil
}
// may return error types nil, or ConnectionError. Any other error value
// is a StreamError of type ErrCodeProtocol. The returned error in that case
// is the detail.
//
// As a special case, handleResponse may return (nil, nil) to skip the
// frame (currently only used for 1xx responses).
func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFrame) (*http.Response, error) {
if f.Truncated {
return nil, errResponseHeaderListSize
}
status := f.PseudoValue("status")
if status == "" {
return nil, errors.New("malformed response from server: missing status pseudo header")
}
statusCode, err := strconv.Atoi(status)
if err != nil {
return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
}
regularFields := f.RegularFields()
strs := make([]string, len(regularFields))
header := make(http.Header, len(regularFields))
res := &http.Response{
Proto: "HTTP/2.0",
ProtoMajor: 2,
Header: header,
StatusCode: statusCode,
Status: status + " " + http.StatusText(statusCode),
}
for _, hf := range regularFields {
key := canonicalHeader(hf.Name)
if key == "Trailer" {
t := res.Trailer
if t == nil {
t = make(http.Header)
res.Trailer = t
}
foreachHeaderElement(hf.Value, func(v string) {
t[canonicalHeader(v)] = nil
})
} else {
vv := header[key]
if vv == nil && len(strs) > 0 {
// More than likely this will be a single-element key.
// Most headers aren't multi-valued.
// Set the capacity on strs[0] to 1, so any future append
// won't extend the slice into the other strings.
vv, strs = strs[:1:1], strs[1:]
vv[0] = hf.Value
header[key] = vv
} else {
header[key] = append(vv, hf.Value)
}
}
}
if statusCode >= 100 && statusCode <= 199 {
if f.StreamEnded() {
return nil, errors.New("1xx informational response with END_STREAM flag")
}
cs.num1xx++
const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http
if cs.num1xx > max1xxResponses {
return nil, errors.New("http2: too many 1xx informational responses")
}
if fn := cs.get1xxTraceFunc(); fn != nil {
if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil {
return nil, err
}
}
if statusCode == 100 {
traceGot100Continue(cs.trace)
select {
case cs.on100 <- struct{}{}:
default:
}
}
cs.pastHeaders = false // do it all again
return nil, nil
}
res.ContentLength = -1
if clens := res.Header["Content-Length"]; len(clens) == 1 {
if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil {
res.ContentLength = int64(cl)
} else {
// TODO: care? unlike http/1, it won't mess up our framing, so it's
// more safe smuggling-wise to ignore.
}
} else if len(clens) > 1 {
// TODO: care? unlike http/1, it won't mess up our framing, so it's
// more safe smuggling-wise to ignore.
} else if f.StreamEnded() && !cs.isHead {
res.ContentLength = 0
}
if cs.isHead {
res.Body = noBody
return res, nil
}
if f.StreamEnded() {
if res.ContentLength > 0 {
res.Body = missingBody{}
} else {
res.Body = noBody
}
return res, nil
}
cs.bufPipe.setBuffer(&dataBuffer{expected: res.ContentLength})
cs.bytesRemain = res.ContentLength
res.Body = transportResponseBody{cs}
if cs.requestedGzip && asciiEqualFold(res.Header.Get("Content-Encoding"), "gzip") {
res.Header.Del("Content-Encoding")
res.Header.Del("Content-Length")
res.ContentLength = -1
res.Body = &gzipReader{body: res.Body}
res.Uncompressed = true
}
return res, nil
}
func (rl *clientConnReadLoop) processTrailers(cs *clientStream, f *MetaHeadersFrame) error {
if cs.pastTrailers {
// Too many HEADERS frames for this stream.
return ConnectionError(ErrCodeProtocol)
}
cs.pastTrailers = true
if !f.StreamEnded() {
// We expect that any headers for trailers also
// has END_STREAM.
return ConnectionError(ErrCodeProtocol)
}
if len(f.PseudoFields()) > 0 {
// No pseudo header fields are defined for trailers.
// TODO: ConnectionError might be overly harsh? Check.
return ConnectionError(ErrCodeProtocol)
}
trailer := make(http.Header)
for _, hf := range f.RegularFields() {
key := canonicalHeader(hf.Name)
trailer[key] = append(trailer[key], hf.Value)
}
cs.trailer = trailer
rl.endStream(cs)
return nil
}
// transportResponseBody is the concrete type of Transport.RoundTrip's
// Response.Body. It is an io.ReadCloser.
type transportResponseBody struct {
cs *clientStream
}
func (b transportResponseBody) Read(p []byte) (n int, err error) {
cs := b.cs
cc := cs.cc
if cs.readErr != nil {
return 0, cs.readErr
}
n, err = b.cs.bufPipe.Read(p)
if cs.bytesRemain != -1 {
if int64(n) > cs.bytesRemain {
n = int(cs.bytesRemain)
if err == nil {
err = errors.New("net/http: server replied with more than declared Content-Length; truncated")
cs.abortStream(err)
}
cs.readErr = err
return int(cs.bytesRemain), err
}
cs.bytesRemain -= int64(n)
if err == io.EOF && cs.bytesRemain > 0 {
err = io.ErrUnexpectedEOF
cs.readErr = err
return n, err
}
}
if n == 0 {
// No flow control tokens to send back.
return
}
cc.mu.Lock()
connAdd := cc.inflow.add(n)
var streamAdd int32
if err == nil { // No need to refresh if the stream is over or failed.
streamAdd = cs.inflow.add(n)
}
cc.mu.Unlock()
if connAdd != 0 || streamAdd != 0 {
cc.wmu.Lock()
defer cc.wmu.Unlock()
if connAdd != 0 {
cc.fr.WriteWindowUpdate(0, mustUint31(connAdd))
}
if streamAdd != 0 {
cc.fr.WriteWindowUpdate(cs.ID, mustUint31(streamAdd))
}
cc.bw.Flush()
}
return
}
var errClosedResponseBody = errors.New("http2: response body closed")
func (b transportResponseBody) Close() error {
cs := b.cs
cc := cs.cc
unread := cs.bufPipe.Len()
if unread > 0 {
cc.mu.Lock()
// Return connection-level flow control.
connAdd := cc.inflow.add(unread)
cc.mu.Unlock()
// TODO(dneil): Acquiring this mutex can block indefinitely.
// Move flow control return to a goroutine?
cc.wmu.Lock()
// Return connection-level flow control.
if connAdd > 0 {
cc.fr.WriteWindowUpdate(0, uint32(connAdd))
}
cc.bw.Flush()
cc.wmu.Unlock()
}
cs.bufPipe.BreakWithError(errClosedResponseBody)
cs.abortStream(errClosedResponseBody)
select {
case <-cs.donec:
case <-cs.ctx.Done():
// See golang/go#49366: The net/http package can cancel the
// request context after the response body is fully read.
// Don't treat this as an error.
return nil
case <-cs.reqCancel:
return errRequestCanceled
}
return nil
}
func (rl *clientConnReadLoop) processData(f *DataFrame) error {
cc := rl.cc
cs := rl.streamByID(f.StreamID)
data := f.Data()
if cs == nil {
cc.mu.Lock()
neverSent := cc.nextStreamID
cc.mu.Unlock()
if f.StreamID >= neverSent {
// We never asked for this.
cc.logf("http2: Transport received unsolicited DATA frame; closing connection")
return ConnectionError(ErrCodeProtocol)
}
// We probably did ask for this, but canceled. Just ignore it.
// TODO: be stricter here? only silently ignore things which
// we canceled, but not things which were closed normally
// by the peer? Tough without accumulating too much state.
// But at least return their flow control:
if f.Length > 0 {
cc.mu.Lock()
ok := cc.inflow.take(f.Length)
connAdd := cc.inflow.add(int(f.Length))
cc.mu.Unlock()
if !ok {
return ConnectionError(ErrCodeFlowControl)
}
if connAdd > 0 {
cc.wmu.Lock()
cc.fr.WriteWindowUpdate(0, uint32(connAdd))
cc.bw.Flush()
cc.wmu.Unlock()
}
}
return nil
}
if cs.readClosed {
cc.logf("protocol error: received DATA after END_STREAM")
rl.endStreamError(cs, StreamError{
StreamID: f.StreamID,
Code: ErrCodeProtocol,
})
return nil
}
if !cs.firstByte {
cc.logf("protocol error: received DATA before a HEADERS frame")
rl.endStreamError(cs, StreamError{
StreamID: f.StreamID,
Code: ErrCodeProtocol,
})
return nil
}
if f.Length > 0 {
if cs.isHead && len(data) > 0 {
cc.logf("protocol error: received DATA on a HEAD request")
rl.endStreamError(cs, StreamError{
StreamID: f.StreamID,
Code: ErrCodeProtocol,
})
return nil
}
// Check connection-level flow control.
cc.mu.Lock()
if !takeInflows(&cc.inflow, &cs.inflow, f.Length) {
cc.mu.Unlock()
return ConnectionError(ErrCodeFlowControl)
}
// Return any padded flow control now, since we won't
// refund it later on body reads.
var refund int
if pad := int(f.Length) - len(data); pad > 0 {
refund += pad
}
didReset := false
var err error
if len(data) > 0 {
if _, err = cs.bufPipe.Write(data); err != nil {
// Return len(data) now if the stream is already closed,
// since data will never be read.
didReset = true
refund += len(data)
}
}
sendConn := cc.inflow.add(refund)
var sendStream int32
if !didReset {
sendStream = cs.inflow.add(refund)
}
cc.mu.Unlock()
if sendConn > 0 || sendStream > 0 {
cc.wmu.Lock()
if sendConn > 0 {
cc.fr.WriteWindowUpdate(0, uint32(sendConn))
}
if sendStream > 0 {
cc.fr.WriteWindowUpdate(cs.ID, uint32(sendStream))
}
cc.bw.Flush()
cc.wmu.Unlock()
}
if err != nil {
rl.endStreamError(cs, err)
return nil
}
}
if f.StreamEnded() {
rl.endStream(cs)
}
return nil
}
func (rl *clientConnReadLoop) endStream(cs *clientStream) {
// TODO: check that any declared content-length matches, like
// server.go's (*stream).endStream method.
if !cs.readClosed {
cs.readClosed = true
// Close cs.bufPipe and cs.peerClosed with cc.mu held to avoid a
// race condition: The caller can read io.EOF from Response.Body
// and close the body before we close cs.peerClosed, causing
// cleanupWriteRequest to send a RST_STREAM.
rl.cc.mu.Lock()
defer rl.cc.mu.Unlock()
cs.bufPipe.closeWithErrorAndCode(io.EOF, cs.copyTrailers)
close(cs.peerClosed)
}
}
func (rl *clientConnReadLoop) endStreamError(cs *clientStream, err error) {
cs.readAborted = true
cs.abortStream(err)
}
func (rl *clientConnReadLoop) streamByID(id uint32) *clientStream {
rl.cc.mu.Lock()
defer rl.cc.mu.Unlock()
cs := rl.cc.streams[id]
if cs != nil && !cs.readAborted {
return cs
}
return nil
}
func (cs *clientStream) copyTrailers() {
for k, vv := range cs.trailer {
t := cs.resTrailer
if *t == nil {
*t = make(http.Header)
}
(*t)[k] = vv
}
}
func (rl *clientConnReadLoop) processGoAway(f *GoAwayFrame) error {
cc := rl.cc
cc.t.connPool().MarkDead(cc)
if f.ErrCode != 0 {
// TODO: deal with GOAWAY more. particularly the error code
cc.vlogf("transport got GOAWAY with error code = %v", f.ErrCode)
if fn := cc.t.CountError; fn != nil {
fn("recv_goaway_" + f.ErrCode.stringToken())
}
}
cc.setGoAway(f)
return nil
}
func (rl *clientConnReadLoop) processSettings(f *SettingsFrame) error {
cc := rl.cc
// Locking both mu and wmu here allows frame encoding to read settings with only wmu held.
// Acquiring wmu when f.IsAck() is unnecessary, but convenient and mostly harmless.
cc.wmu.Lock()
defer cc.wmu.Unlock()
if err := rl.processSettingsNoWrite(f); err != nil {
return err
}
if !f.IsAck() {
cc.fr.WriteSettingsAck()
cc.bw.Flush()
}
return nil
}
func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error {
cc := rl.cc
cc.mu.Lock()
defer cc.mu.Unlock()
if f.IsAck() {
if cc.wantSettingsAck {
cc.wantSettingsAck = false
return nil
}
return ConnectionError(ErrCodeProtocol)
}
var seenMaxConcurrentStreams bool
err := f.ForeachSetting(func(s Setting) error {
switch s.ID {
case SettingMaxFrameSize:
cc.maxFrameSize = s.Val
case SettingMaxConcurrentStreams:
cc.maxConcurrentStreams = s.Val
seenMaxConcurrentStreams = true
case SettingMaxHeaderListSize:
cc.peerMaxHeaderListSize = uint64(s.Val)
case SettingInitialWindowSize:
// Values above the maximum flow-control
// window size of 2^31-1 MUST be treated as a
// connection error (Section 5.4.1) of type
// FLOW_CONTROL_ERROR.
if s.Val > math.MaxInt32 {
return ConnectionError(ErrCodeFlowControl)
}
// Adjust flow control of currently-open
// frames by the difference of the old initial
// window size and this one.
delta := int32(s.Val) - int32(cc.initialWindowSize)
for _, cs := range cc.streams {
cs.flow.add(delta)
}
cc.cond.Broadcast()
cc.initialWindowSize = s.Val
case SettingHeaderTableSize:
cc.henc.SetMaxDynamicTableSize(s.Val)
cc.peerMaxHeaderTableSize = s.Val
default:
cc.vlogf("Unhandled Setting: %v", s)
}
return nil
})
if err != nil {
return err
}
if !cc.seenSettings {
if !seenMaxConcurrentStreams {
// This was the servers initial SETTINGS frame and it
// didn't contain a MAX_CONCURRENT_STREAMS field so
// increase the number of concurrent streams this
// connection can establish to our default.
cc.maxConcurrentStreams = defaultMaxConcurrentStreams
}
cc.seenSettings = true
}
return nil
}
func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error {
cc := rl.cc
cs := rl.streamByID(f.StreamID)
if f.StreamID != 0 && cs == nil {
return nil
}
cc.mu.Lock()
defer cc.mu.Unlock()
fl := &cc.flow
if cs != nil {
fl = &cs.flow
}
if !fl.add(int32(f.Increment)) {
return ConnectionError(ErrCodeFlowControl)
}
cc.cond.Broadcast()
return nil
}
func (rl *clientConnReadLoop) processResetStream(f *RSTStreamFrame) error {
cs := rl.streamByID(f.StreamID)
if cs == nil {
// TODO: return error if server tries to RST_STREAM an idle stream
return nil
}
serr := streamError(cs.ID, f.ErrCode)
serr.Cause = errFromPeer
if f.ErrCode == ErrCodeProtocol {
rl.cc.SetDoNotReuse()
}
if fn := cs.cc.t.CountError; fn != nil {
fn("recv_rststream_" + f.ErrCode.stringToken())
}
cs.abortStream(serr)
cs.bufPipe.CloseWithError(serr)
return nil
}
// Ping sends a PING frame to the server and waits for the ack.
func (cc *ClientConn) Ping(ctx context.Context) error {
c := make(chan struct{})
// Generate a random payload
var p [8]byte
for {
if _, err := rand.Read(p[:]); err != nil {
return err
}
cc.mu.Lock()
// check for dup before insert
if _, found := cc.pings[p]; !found {
cc.pings[p] = c
cc.mu.Unlock()
break
}
cc.mu.Unlock()
}
errc := make(chan error, 1)
go func() {
cc.wmu.Lock()
defer cc.wmu.Unlock()
if err := cc.fr.WritePing(false, p); err != nil {
errc <- err
return
}
if err := cc.bw.Flush(); err != nil {
errc <- err
return
}
}()
select {
case <-c:
return nil
case err := <-errc:
return err
case <-ctx.Done():
return ctx.Err()
case <-cc.readerDone:
// connection closed
return cc.readerErr
}
}
func (rl *clientConnReadLoop) processPing(f *PingFrame) error {
if f.IsAck() {
cc := rl.cc
cc.mu.Lock()
defer cc.mu.Unlock()
// If ack, notify listener if any
if c, ok := cc.pings[f.Data]; ok {
close(c)
delete(cc.pings, f.Data)
}
return nil
}
cc := rl.cc
cc.wmu.Lock()
defer cc.wmu.Unlock()
if err := cc.fr.WritePing(true, f.Data); err != nil {
return err
}
return cc.bw.Flush()
}
func (rl *clientConnReadLoop) processPushPromise(f *PushPromiseFrame) error {
// We told the peer we don't want them.
// Spec says:
// "PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH
// setting of the peer endpoint is set to 0. An endpoint that
// has set this setting and has received acknowledgement MUST
// treat the receipt of a PUSH_PROMISE frame as a connection
// error (Section 5.4.1) of type PROTOCOL_ERROR."
return ConnectionError(ErrCodeProtocol)
}
func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, err error) {
// TODO: map err to more interesting error codes, once the
// HTTP community comes up with some. But currently for
// RST_STREAM there's no equivalent to GOAWAY frame's debug
// data, and the error codes are all pretty vague ("cancel").
cc.wmu.Lock()
cc.fr.WriteRSTStream(streamID, code)
cc.bw.Flush()
cc.wmu.Unlock()
}
var (
errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit")
)
func (cc *ClientConn) logf(format string, args ...interface{}) {
cc.t.logf(format, args...)
}
func (cc *ClientConn) vlogf(format string, args ...interface{}) {
cc.t.vlogf(format, args...)
}
func (t *Transport) vlogf(format string, args ...interface{}) {
if VerboseLogs {
t.logf(format, args...)
}
}
func (t *Transport) logf(format string, args ...interface{}) {
log.Printf(format, args...)
}
var noBody io.ReadCloser = noBodyReader{}
type noBodyReader struct{}
func (noBodyReader) Close() error { return nil }
func (noBodyReader) Read([]byte) (int, error) { return 0, io.EOF }
type missingBody struct{}
func (missingBody) Close() error { return nil }
func (missingBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF }
func strSliceContains(ss []string, s string) bool {
for _, v := range ss {
if v == s {
return true
}
}
return false
}
type erringRoundTripper struct{ err error }
func (rt erringRoundTripper) RoundTripErr() error { return rt.err }
func (rt erringRoundTripper) RoundTrip(*http.Request) (*http.Response, error) { return nil, rt.err }
// gzipReader wraps a response body so it can lazily
// call gzip.NewReader on the first call to Read
type gzipReader struct {
_ incomparable
body io.ReadCloser // underlying Response.Body
zr *gzip.Reader // lazily-initialized gzip reader
zerr error // sticky error
}
func (gz *gzipReader) Read(p []byte) (n int, err error) {
if gz.zerr != nil {
return 0, gz.zerr
}
if gz.zr == nil {
gz.zr, err = gzip.NewReader(gz.body)
if err != nil {
gz.zerr = err
return 0, err
}
}
return gz.zr.Read(p)
}
func (gz *gzipReader) Close() error {
if err := gz.body.Close(); err != nil {
return err
}
gz.zerr = fs.ErrClosed
return nil
}
type errorReader struct{ err error }
func (r errorReader) Read(p []byte) (int, error) { return 0, r.err }
// isConnectionCloseRequest reports whether req should use its own
// connection for a single request and then close the connection.
func isConnectionCloseRequest(req *http.Request) bool {
return req.Close || httpguts.HeaderValuesContainsToken(req.Header["Connection"], "close")
}
// registerHTTPSProtocol calls Transport.RegisterProtocol but
// converting panics into errors.
func registerHTTPSProtocol(t *http.Transport, rt noDialH2RoundTripper) (err error) {
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
t.RegisterProtocol("https", rt)
return nil
}
// noDialH2RoundTripper is a RoundTripper which only tries to complete the request
// if there's already has a cached connection to the host.
// (The field is exported so it can be accessed via reflect from net/http; tested
// by TestNoDialH2RoundTripperType)
type noDialH2RoundTripper struct{ *Transport }
func (rt noDialH2RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
res, err := rt.Transport.RoundTrip(req)
if isNoCachedConnError(err) {
return nil, http.ErrSkipAltProtocol
}
return res, err
}
func (t *Transport) idleConnTimeout() time.Duration {
if t.t1 != nil {
return t.t1.IdleConnTimeout
}
return 0
}
func traceGetConn(req *http.Request, hostPort string) {
trace := httptrace.ContextClientTrace(req.Context())
if trace == nil || trace.GetConn == nil {
return
}
trace.GetConn(hostPort)
}
func traceGotConn(req *http.Request, cc *ClientConn, reused bool) {
trace := httptrace.ContextClientTrace(req.Context())
if trace == nil || trace.GotConn == nil {
return
}
ci := httptrace.GotConnInfo{Conn: cc.tconn}
ci.Reused = reused
cc.mu.Lock()
ci.WasIdle = len(cc.streams) == 0 && reused
if ci.WasIdle && !cc.lastActive.IsZero() {
ci.IdleTime = time.Since(cc.lastActive)
}
cc.mu.Unlock()
trace.GotConn(ci)
}
func traceWroteHeaders(trace *httptrace.ClientTrace) {
if trace != nil && trace.WroteHeaders != nil {
trace.WroteHeaders()
}
}
func traceGot100Continue(trace *httptrace.ClientTrace) {
if trace != nil && trace.Got100Continue != nil {
trace.Got100Continue()
}
}
func traceWait100Continue(trace *httptrace.ClientTrace) {
if trace != nil && trace.Wait100Continue != nil {
trace.Wait100Continue()
}
}
func traceWroteRequest(trace *httptrace.ClientTrace, err error) {
if trace != nil && trace.WroteRequest != nil {
trace.WroteRequest(httptrace.WroteRequestInfo{Err: err})
}
}
func traceFirstResponseByte(trace *httptrace.ClientTrace) {
if trace != nil && trace.GotFirstResponseByte != nil {
trace.GotFirstResponseByte()
}
}
```
|
```c++
/*
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "PointsToSemanticsUtils.h"
#include "DexClass.h"
#include "IROpcode.h"
#include "Resolver.h"
bool PointsToSemanticsUtils::is_primitive_type_class_object_retrieval(
IRInstruction* insn) const {
always_assert(insn->opcode() == OPCODE_SGET_OBJECT);
DexField* dex_field = resolve_field(insn->get_field(), FieldSearch::Static);
return dex_field != nullptr &&
is_primitive_type_wrapper(dex_field->get_class()) &&
(dex_field->get_name() == m_wrapper_class_type_field_name);
}
bool PointsToSemanticsUtils::is_get_class_invocation(
IRInstruction* insn) const {
return (insn->opcode() == OPCODE_INVOKE_VIRTUAL) &&
(insn->get_method() == m_java_lang_object_get_class);
}
```
|
A spigot algorithm is an algorithm for computing the value of a transcendental number (such as or e) that generates the digits of the number sequentially from left to right providing increasing precision as the algorithm proceeds. Spigot algorithms also aim to minimize the amount of intermediate storage required. The name comes from the sense of the word "spigot" for a tap or valve controlling the flow of a liquid. Spigot algorithms can be contrasted with algorithms that store and process complete numbers to produce successively more accurate approximations to the desired transcendental.
Interest in spigot algorithms was spurred in the early days of computational mathematics by extreme constraints on memory, and such an algorithm for calculating the digits of e appeared in a paper by Sale in 1968. In 1970, Abdali presented a more general algorithm to compute the sums of series in which the ratios of successive terms can be expressed as quotients of integer functions of term positions. This algorithm is applicable to many familiar series for trigonometric functions, logarithms, and transcendental numbers because these series satisfy the above condition. The name "spigot algorithm" seems to have been coined by Stanley Rabinowitz and Stan Wagon, whose algorithm for calculating the digits of is sometimes referred to as "the spigot algorithm for ".
The spigot algorithm of Rabinowitz and Wagon is bounded, in the sense that the number of terms of the infinite series that will be processed must be specified in advance. The term "streaming algorithm" indicates an approach without this restriction. This allows the calculation to run indefinitely varying the amount of intermediate storage as the calculation progresses.
A variant of the spigot approach uses an algorithm which can be used to compute a single arbitrary digit of the transcendental without computing the preceding digits: an example is the Bailey–Borwein–Plouffe formula, a digit extraction algorithm for which produces base 16 digits. The inevitable truncation of the underlying infinite series of the algorithm means that the accuracy of the result may be limited by the number of terms calculated.
Example
This example illustrates the working of a spigot algorithm by calculating the binary digits of the natural logarithm of 2 using the identity
To start calculating binary digits from, as an example, the 8th place we multiply this identity by 27 (since 7 = 8 − 1):
We then divide the infinite sum into a "head", in which the exponents of 2 are greater than or equal to zero, and a "tail", in which the exponents of 2 are negative:
We are only interested in the fractional part of this value, so we can replace each of the summands in the "head" by
Calculating each of these terms and adding them to a running total where we again only keep the fractional part, we have:
{| class="wikitable"
|-
! k
! A = 27−k
! B = A mod k
! C =
! Sum of C mod 1
|-
| 1
| 64
| 0
| 0
| 0
|-
| 2
| 32
| 0
| 0
| 0
|-
| 3
| 16
| 1
|
|
|-
| 4
| 8
| 0
| 0
|
|-
| 5
| 4
| 4
|
|
|-
| 6
| 2
| 2
|
|
|-
| 7
| 1
| 1
|
|
|}
We add a few terms in the "tail", noting that the error introduced by truncating the sum is less than the final term:
{| class="wikitable"
|-
! k
! D =
! Sum of D
! Maximum error
|-
| 8
|
|
|
|-
| 9
|
|
|
|-
| 10
|
|
|
|}
Adding the "head" and the first few terms of the "tail" together we get:
so the 8th to 11th binary digits in the binary expansion of ln(2) are 1, 0, 1, 1. Note that we have not calculated the values of the first seven binary digits – indeed, all information about them has been intentionally discarded by using modular arithmetic in the "head" sum.
The same approach can be used to calculate digits of the binary expansion of ln(2) starting from an arbitrary nth position. The number of terms in the "head" sum increases linearly with n, but the complexity of each term only increases with the logarithm of n if an efficient method of modular exponentiation is used. The precision of calculations and intermediate results and the number of terms taken from the "tail" sum are all independent of n, and only depend on the number of binary digits that are being calculated – single precision arithmetic can be used to calculate around 12 binary digits, regardless of the starting position.
References
Further reading
Arndt, Jorg; Haenel, Christoph, unleashed, Springer Verlag, 2000.
Computer arithmetic algorithms
|
```xml
import { hasBasePath } from './has-base-path'
const basePath = (process.env.__NEXT_ROUTER_BASEPATH as string) || ''
export function removeBasePath(path: string): string {
if (process.env.__NEXT_MANUAL_CLIENT_BASE_PATH) {
if (!hasBasePath(path)) {
return path
}
}
// Can't trim the basePath if it has zero length!
if (basePath.length === 0) return path
path = path.slice(basePath.length)
if (!path.startsWith('/')) path = `/${path}`
return path
}
```
|
```yaml
{{- /*
*/}}
{{- if not .Values.mariadb.enabled }}
apiVersion: v1
kind: Secret
metadata:
name: {{ printf "%s-%s" .Release.Name "externaldb" | trunc 63 | trimSuffix "-" }}
namespace: {{ include "common.names.namespace" . | quote }}
labels: {{- include "common.labels.standard" ( dict "customLabels" .Values.commonLabels "context" $ ) | nindent 4 }}
{{- if .Values.commonAnnotations }}
annotations: {{- include "common.tplvalues.render" ( dict "value" .Values.commonAnnotations "context" $ ) | nindent 4 }}
{{- end }}
type: Opaque
data:
mariadb-password: {{ .Values.externalDatabase.password | b64enc | quote }}
{{- end }}
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.