text
stringlengths 1
22.8M
|
|---|
```xml
// path_to_url~oz/hash.html
// More specifically, 32-bit hash via djbxor
// (ref: path_to_url#gistcomment-3367765)
// This is due to number type differences between rust for turbopack to js number types,
// where rust does not have easy way to repreesnt js's 53-bit float number type for the matching
// overflow behavior. This is more `correct` in terms of having canonical hash across different runtime / implementation
// as can gaurantee determinstic output from 32bit hash.
export function djb2Hash(str: string) {
let hash = 5381
for (let i = 0; i < str.length; i++) {
const char = str.charCodeAt(i)
hash = ((hash << 5) + hash + char) & 0xffffffff
}
return hash >>> 0
}
export function hexHash(str: string) {
return djb2Hash(str).toString(36).slice(0, 5)
}
```
|
Paul Owens is the author of the bestselling dog training book, The Dog Whisperer, Beginning and Intermediate Training for Puppies and Dogs (1999; 2nd edition 2007). His newest puppy training book is The Puppy Whisperer, A Compassionate, Nonviolent Guide to Early Training and Care (2007).
Paul is a leading proponent of positive dog training methods. He is a long-standing member of the Association of Pet Dog Trainers. He is not associated with Cesar Millan or the National Geographic Channel Dog Whisperer TV series.
References
Paul Owens, The Original Dog Whisperer
APDT Recommended Books and DVDs
Dog trainers
Year of birth missing (living people)
Place of birth missing (living people)
Living people
|
Marie Françoise Catherine de Beauvau, Marquise of Boufflers (8 December 1711 – 1 July 1786), commonly known as Madame de Boufflers, was a French noblewoman. She was the royal mistress of Stanislas Leszczyński and mother of the poet Stanislas de Boufflers.
Family
Her father was Marc de Beauvau, Prince of Craon, and her mother was Anne Marguerite de Lignéville (1686–1772), mistress of Leopold, Duke of Lorraine. She had nineteen siblings, including Charles Juste de Beauvau, through whom she was a sister-in-law of Marie Charlotte de La Tour d'Auvergne. Marie Françoise Catherine married Louis François de Boufflers (1714–1752), Marquis of Amestranges, with whom she had Stanislas de Boufflers, later famous as a poet.
Biography
Witty, well-educated and beautiful, the marquise de Boufflers wrote verse and drew in pastel. At the court at Lunéville, aged 34, she became the chief mistress to king Stanislas, then aged 64. This did not stop her also collecting other lovers; nicknamed La Dame de Volupté ("the lady of delight"), she was also the mistress of the poet Jean François de Saint-Lambert, then of M. of Adhémar, of the intendant de Lorraine Antoine-Martin Chaumont de La Galaizière, of the lawyer and poet François-Antoine Devaux.
To try to make the Marquise de Boufflers jealous and regain her affections, Saint-Lambert attempted to seduce the Marquise du Châtelet when the latter arrived in Lunéville in 1748. The Marquise du Châtelet fell passionately in love with the poet and became best friends with the Marquise de Boufflers, thus completely ruining the plans of Father Menou, Stanislas' confessor, who wanted to use her to dislodge the Marquise de Boufflers as chief mistress to the king.
Her witty poem "Sentir avec ardeur" is cited in French and in full by the twentieth-century Modernist poet Marianne Moore in the notes to Moore's poem "Tom Fool at Jamaica."
Stanislaus I had a chartreuse cottage constructed along the northern side of the Palace of Lunéville.
References
1711 births
1786 deaths
Marie-Francoise
French marchionesses
Mistresses of Polish royalty
People from Lunéville
|
Contai III (also known as Kanthi III block) is a community development block that forms an administrative division in Contai subdivision of Purba Medinipur district in the Indian state of West Bengal.
Geography
Purba Medinipur district is part of the lower Indo-Gangetic Plain and Eastern coastal plains. Topographically, the district can be divided into two parts – (a) almost entirely flat plains on the west, east and north, (b) the coastal plains on the south. The vast expanse of land is formed of alluvium and is composed of younger and coastal alluvial. The elevation of the district is within 10 metres above mean sea level. The district has a long coastline of 65.5 km along its southern and south eastern boundary. Five coastal CD Blocks, namely, Khejuri II, Contai II (Deshapran), Contai I, Ramnagar I and II, are occasionally affected by cyclones and tornadoes. Tidal floods are quite regular in these five CD Blocks. Normally floods occur in 21 of the 25 CD Blocks in the district. The major rivers are Haldi, Rupnarayan, Rasulpur, Bagui and Keleghai, flowing in north to south or south-east direction. River water is an important source of irrigation. The district has a low 899 hectare forest cover, which is 0.02% of its geographical area.
Durmuth, a constituent panchayat of Contai III block, is located at .
Contai III CD Block is bounded by Bhagabanpur II and Khejuri I CD Blocks in the north, Deshapran CD Block in the east, Contai I CD Block in the south and Egra II CD Block in the west.
It is located 59 km from Tamluk, the district headquarters.
Contai III CD Block has an area of 160.52 km2. It has 1 panchayat samity, 8 gram panchayats, 117 gram sansads (village councils), 165 mouzas and 166 inhabited villages. Marishda police station serves this block. Headquarters of this CD Block is at Marishda.
Gram panchayats of Contai III block/ panchayat samiti are: Bhajachauli, Debendra, Durmuth, Kaniadighi, Kumirda, Kusumpur, Lauda and Marishda.
Demographics
Population
As per 2011 Census of India Contai III CD Block had a total population of 157,793, all of which were rural. There were 81,143 (51%) males and 76,650 (49%) females. Population below 6 years was 17,985. Scheduled Castes numbered 20,832 (13.20%) and Scheduled Tribes numbered 144 (0.09%).
As per 2001 census, Contai III block had a total population of 137,364, out of which 70,418 were males and 66,946 were females. Contai III block registered a population growth of 12.52 per cent during the 1991-2001 decade. Decadal growth for the combined Midnapore district was 14.87 per cent. Decadal growth in West Bengal was 17.84 per cent.
Large villages (with 4,000+ population) in Contai III CD Block (2011 census figures in brackets): Marishda (5,953), Kanaidighi (8,783).
Other villages in Contai III CD Block (2011 census figures in brackets): Bhaja Chauli (2,541), Kumirda (3,625), Lauda (1,124), Dihibahiri (161).
Literacy
As per 2011 census the total number of literates in Contai III CD Block was 125,656 (89.88% of the population over 6 years) out of which 68,135 (54%) were males and 57,541 (46%) were females.
As per 2011 census, literacy in Purba Medinipur district was 87.02%. Purba Medinipur had the highest literacy amongst all the districts of West Bengal in 2011.
See also – List of West Bengal districts ranked by literacy rate
Language and religion
In the 2011 census Hindus numbered 152,038 and formed 96.35% of the population in Contai III CD Block. Muslims numbered 5,584 and formed 3.54% of the population. Others numbered 171 and formed 0.11% of the population. In 2001, Hindus made up 96.39% and Muslims 3.54% of the population respectively.
Bengali is the predominant language, spoken by 98.55% of the population.
Rural poverty
The District Human Development Report for Purba Medinipur has provided a CD Block-wise data table for Modified Human Poverty Index of the district. Contai III CD Block registered 29.68 on the MHPI scale. The CD Block-wise mean MHPI was estimated at 24.78. Eleven out of twentyfive CD Blocks were found to be severely deprived in respect of grand CD Block average value of MHPI (CD Blocks with lower amount of poverty are better): All the CD Blocks of Haldia and Contai subdivisions appeared backward, except Ramnagar I & II, of all the blocks of Egra subdivision only Bhagabanpur I appeared backward and in Tamluk subdivision none appeared backward.
Economy
Livelihood
In Contai III CD Block in 2011, total workers formed 41.29% of the total population and amongst the class of total workers, cultivators formed 19.18%, agricultural labourers 33.94%, household industry workers 7.18% and other workers 39.70.%.
Infrastructure
There are 166 inhabited villages in Contai III CD block. All 166 villages (100%) have power supply. 164 villages (98.8%) have drinking water supply. 27 villages (16.27%) have post offices. 155 villages (93.37%) have telephones (including landlines, public call offices and mobile phones). 25 villages (15.06%) have a pucca (paved) approach road and 31 villages (18.67%) have transport communication (includes bus service, rail facility and navigable waterways). 35 villages (31.08%) have agricultural credit societies. 13 villages (7.83%) have banks.
In 2007-08, around 40% of rural households in the district had electricity.
In 2013-14, there were 71 fertiliser depots, 12 seed stores and 32 fair price shops in the CD Block.
Agriculture
According to the District Human Development Report of Purba Medinipur: The agricultural sector is the lifeline of a predominantly rural economy. It is largely dependent on the Low Capacity Deep Tubewells (around 50%) or High Capacity Deep Tubewells (around 27%) for irrigation, as the district does not have a good network of canals, compared to some of the neighbouring districts. In many cases the canals are drainage canals which get the backflow of river water at times of high tide or the rainy season. The average size of land holding in Purba Medinipur, in 2005-06, was 0.73 hectares against 1.01 hectares in West Bengal.
In 2013-14, the total area irrigated in Contai III CD Block was 4,953 hectares, out of which 2,543 hectares were irrigated by tank water, 1,710 hectares by deep tube well and 700 hectares by shallow tube well.
Although the Bargadari Act of 1950 recognised the rights of bargadars to a higher share of crops from the land that they tilled, it was not implemented fully. Large tracts, beyond the prescribed limit of land ceiling, remained with the rich landlords. From 1977 onwards major land reforms took place in West Bengal. Land in excess of land ceiling was acquired and distributed amongst the peasants. Following land reforms land ownership pattern has undergone transformation. In 2013-14, persons engaged in agriculture in Contai III CD Block could be classified as follows: bargadars 7.19%, patta (document) holders 27.28%, small farmers (possessing land between 1 and 2 hectares) 2.66%, marginal farmers (possessing land up to 1 hectare) 29.45% and agricultural labourers 33.42%.
In 2013-14, Contai III CD Block produced 18,098 tonnes of Aman paddy, the main winter crop, from 13,195 hectares, 6,413 tonnes of Boro paddy, the spring crop, from 2,095 hectares and 118 tonnes of potatoes from 164 hectares. It also produced oil seeds.
Betelvine is a major source of livelihood in Purba Medinipur district, particularly in Tamluk and Contai subdivisions. Betelvine production in 2008-09 was the highest amongst all the districts and was around a third of the total state production. In 2008-09, Purba Mednipur produced 2,789 tonnes of cashew nuts from 3,340 hectares of land.
Pisciculture
Purba Medinipur's net district domestic product derives one fifth of its earnings from fisheries, the highest amongst all the districts of West Bengal. The nett area available for effective pisciculture in Contai III CD Block in 2013-14 was 750.60 hectares. 2,755 persons were engaged in the profession and approximate annual production was 28,598 quintals.
Banking
In 2013-14, Contai III CD Block had offices of 4 commercial banks and 3 gramin banks.
Backward Regions Grant Fund
Medinipur East district is listed as a backward region and receives financial support from the Backward Regions Grant Fund. The fund, created by the Government of India, is designed to redress regional imbalances in development. As of 2012, 272 districts across the country were listed under this scheme. The list includes 11 districts of West Bengal.
Transport
Contai III CD Block has 3 ferry services, 3 originating/ terminating bus routes.
Education
In 2013-14, Contai III CD Block had 132 primary schools with 5,934 students, 14 middle schools with 828 students, 8 high schools with 6,216 students and 11 higher secondary schools with 12,443 students. Contai III CD Block had 1 general college with 538 students and 290 institutions for special and non-formal education with 12,305 students.
As per the 2011 census, in Contai III CD block, amongst the 166 inhabited villages, 21/22 villages did not have a school, 49 villages had two or more primary schools, 35 villages had at least 1 primary and 1 middle school and 23 villages had at least 1 middle and 1 secondary school.
Healthcare
In 2014, Contai III CD Block had 1 block primary health centre and 2 primary health centres with total 10 beds and 5 doctors (excluding private bodies). It had 24 family welfare sub centres. 515 patients were treated indoor and 126,451 patients were treated outdoor in the hospitals, health centres and subcentres of the CD Block.
Kharipukuria Block Primary Health Centre at Kharipukuria, PO Nachinda Bazar (with 10 beds) is the main medical facility in Contai III CD block. There are primary health centres at Banamalichatta (with 10 beds), Bhaitgarh (with ? beds) and Deulbarh (with 2 beds).
References
Community development blocks in Purba Medinipur district
|
```c
/*
*
*/
#define DT_DRV_COMPAT sbs_sbs_gauge
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/sys/byteorder.h>
#include "sbs_gauge.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(sbs_gauge, CONFIG_SENSOR_LOG_LEVEL);
static int sbs_cmd_reg_read(const struct device *dev,
uint8_t reg_addr,
uint16_t *val)
{
const struct sbs_gauge_config *cfg;
uint8_t i2c_data[2];
int status;
cfg = dev->config;
status = i2c_burst_read_dt(&cfg->i2c, reg_addr, i2c_data,
ARRAY_SIZE(i2c_data));
if (status < 0) {
LOG_ERR("Unable to read register");
return status;
}
*val = sys_get_le16(i2c_data);
return 0;
}
/**
* @brief sensor value get
*
* @return -ENOTSUP for unsupported channels
*/
static int sbs_gauge_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *val)
{
struct sbs_gauge_data *data;
int32_t int_temp;
data = dev->data;
val->val2 = 0;
switch (chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
val->val1 = data->voltage / 1000;
val->val2 = (data->voltage % 1000) * 1000;
break;
case SENSOR_CHAN_GAUGE_AVG_CURRENT:
val->val1 = data->avg_current / 1000;
val->val2 = (data->avg_current % 1000) * 1000;
break;
case SENSOR_CHAN_GAUGE_TEMP:
int_temp = (data->internal_temperature * 10);
int_temp = int_temp - 27315;
val->val1 = int_temp / 100;
val->val2 = (int_temp % 100) * 1000000;
break;
case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
val->val1 = data->state_of_charge;
break;
case SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY:
val->val1 = data->full_charge_capacity;
break;
case SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY:
val->val1 = data->remaining_charge_capacity;
break;
case SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY:
val->val1 = data->nom_avail_capacity;
break;
case SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY:
val->val1 = data->full_avail_capacity;
break;
case SENSOR_CHAN_GAUGE_TIME_TO_EMPTY:
val->val1 = data->time_to_empty;
break;
case SENSOR_CHAN_GAUGE_TIME_TO_FULL:
val->val1 = data->time_to_full;
break;
case SENSOR_CHAN_GAUGE_CYCLE_COUNT:
val->val1 = data->cycle_count;
break;
default:
return -ENOTSUP;
}
return 0;
}
static const uint16_t all_channels[] = {
SENSOR_CHAN_GAUGE_VOLTAGE,
SENSOR_CHAN_GAUGE_AVG_CURRENT,
SENSOR_CHAN_GAUGE_TEMP,
SENSOR_CHAN_GAUGE_STATE_OF_CHARGE,
SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY,
SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY,
SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY,
SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY,
SENSOR_CHAN_GAUGE_TIME_TO_EMPTY,
SENSOR_CHAN_GAUGE_TIME_TO_FULL,
SENSOR_CHAN_GAUGE_CYCLE_COUNT
};
static int sbs_gauge_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct sbs_gauge_data *data;
int status = 0;
data = dev->data;
switch (chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_VOLTAGE,
&data->voltage);
if (status < 0) {
LOG_ERR("Failed to read voltage");
}
break;
case SENSOR_CHAN_GAUGE_AVG_CURRENT:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_AVG_CURRENT,
&data->avg_current);
if (status < 0) {
LOG_ERR("Failed to read average current ");
}
break;
case SENSOR_CHAN_GAUGE_TEMP:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_TEMP,
&data->internal_temperature);
if (status < 0) {
LOG_ERR("Failed to read internal temperature");
}
break;
case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_ASOC,
&data->state_of_charge);
if (status < 0) {
LOG_ERR("Failed to read state of charge");
}
break;
case SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_FULL_CAPACITY,
&data->full_charge_capacity);
if (status < 0) {
LOG_ERR("Failed to read full charge capacity");
}
break;
case SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_REM_CAPACITY,
&data->remaining_charge_capacity);
if (status < 0) {
LOG_ERR("Failed to read remaining charge capacity");
}
break;
case SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_NOM_CAPACITY,
&data->nom_avail_capacity);
if (status < 0) {
LOG_ERR("Failed to read nominal available capacity");
}
break;
case SENSOR_CHAN_GAUGE_FULL_AVAIL_CAPACITY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_FULL_CAPACITY,
&data->full_avail_capacity);
if (status < 0) {
LOG_ERR("Failed to read full available capacity");
}
break;
case SENSOR_CHAN_GAUGE_TIME_TO_EMPTY:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_AVG_TIME2EMPTY,
&data->time_to_empty);
data->time_to_empty = (data->time_to_empty) & 0x00FF;
if (status < 0) {
LOG_ERR("Failed to read time to empty");
}
break;
case SENSOR_CHAN_GAUGE_TIME_TO_FULL:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_AVG_TIME2FULL,
&data->time_to_full);
data->time_to_full = (data->time_to_full) & 0x00FF;
if (status < 0) {
LOG_ERR("Failed to read time to full");
}
break;
case SENSOR_CHAN_GAUGE_CYCLE_COUNT:
status = sbs_cmd_reg_read(dev,
SBS_GAUGE_CMD_CYCLE_COUNT,
&data->cycle_count);
data->cycle_count = (data->cycle_count) & 0x00FF;
if (status < 0) {
LOG_ERR("Failed to read cycle count");
}
break;
case SENSOR_CHAN_ALL:
for (int i = 0; i < ARRAY_SIZE(all_channels); i++) {
status = sbs_gauge_sample_fetch(dev, all_channels[i]);
if (status != 0) {
break;
}
}
break;
default:
return -ENOTSUP;
}
return status;
}
/**
* @brief initialize the fuel gauge
*
* @return 0 for success
*/
static int sbs_gauge_init(const struct device *dev)
{
const struct sbs_gauge_config *cfg;
cfg = dev->config;
if (!device_is_ready(cfg->i2c.bus)) {
LOG_ERR("Bus device is not ready");
return -ENODEV;
}
return 0;
}
static const struct sensor_driver_api sbs_gauge_driver_api = {
.sample_fetch = sbs_gauge_sample_fetch,
.channel_get = sbs_gauge_channel_get,
};
#define SBS_GAUGE_INIT(index) \
static struct sbs_gauge_data sbs_gauge_driver_##index; \
\
static const struct sbs_gauge_config sbs_gauge_config_##index = { \
.i2c = I2C_DT_SPEC_INST_GET(index), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(index, \
&sbs_gauge_init, \
NULL, \
&sbs_gauge_driver_##index, \
&sbs_gauge_config_##index, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&sbs_gauge_driver_api);
DT_INST_FOREACH_STATUS_OKAY(SBS_GAUGE_INIT)
```
|
```shell
How to unstage a staged file
How to unmodify a modified file
Finding a tag
The three states in git
`master` and `origin` aren't special
```
|
```javascript
var http = require('http');
var qs = require('querystring');
var fs = require('fs');
var spawn = require('child_process').spawn;
var helpers = require('./helpers.js');
var v1 = require('./converters/v1.js');
var v2 = require('./converters/v2.js');
var MAX_FILE_SIZE = 5 * 1024 * 1024;
var TMP_DIR_NAME = process.cwd() + '/' + 'tmp/';
var SCRIPT = fs.readFileSync('./save_script_tpl.js', { encoding: 'utf8' });
if (!fs.existsSync(TMP_DIR_NAME)) {
fs.mkdirSync(TMP_DIR_NAME);
}
var defaultHeaders = {
'Content-Type': 'text/plain',
'Access-Control-Allow-Origin': '*'
};
function respond(response, code, data, headers) {
headers = helpers.apply({}, headers, defaultHeaders);
response.writeHead(code, headers);
response.end(data);
}
var counter = (function () {
var value = 0,
max_int = Math.pow(2, 32) - 1;
return function () {
if (value > max_int) {
value = 0;
}
return value++;
}
})();
http.createServer(function (request, response) {
if (request.method === 'POST') {
var body = '';
request.on('data', function (data) {
if (body.length <= MAX_FILE_SIZE) {
body += data;
} else {
respond(response, 413, "Request entity too large.");
}
});
request.on('end', function () {
try {
var config = qs.parse(body);
} catch (e) {
console.error("Parsing request data failed.", e);
}
if (config) {
switch (config.version) {
case '2':
config = v2.convert(config);
break;
default:
config = v1.convert(config);
break;
}
}
if (!config || !config.data) {
respond(response, 400, "Bad request.");
return;
}
var userFileName = (config.filename || 'chart') + '.' + config.format;
var serverFileName = TMP_DIR_NAME + counter().toString() + '.' + config.format;
var scriptFileName = TMP_DIR_NAME + counter().toString() + '.js';
var script = helpers.interpolate(SCRIPT, helpers.apply(config, {
filename: serverFileName
}));
fs.writeFile(scriptFileName, script, { encoding: 'utf8' }, function (err) {
if (err) throw err;
var phantom = spawn('phantomjs', [scriptFileName]);
phantom.stdout.pipe(process.stdout); // proxy console output from phantom to node
phantom.on('exit', function (code) {
fs.unlink(scriptFileName, function () {
if (err) throw err;
console.log("Successfully deleted:", scriptFileName);
});
if (!code) {
fs.readFile(serverFileName, function (err, data) {
if (err) throw err;
respond(response, 200, data, {
'Content-Type': config.contentType,
'Content-Disposition': 'attachment; filename=' + userFileName
});
fs.unlink(serverFileName, function () {
if (err) throw err;
console.log("Successfully deleted:", serverFileName);
});
});
} else {
respond(response, 500, "Internal server error.\n" +
"phantomjs exited with code " + code);
}
});
});
});
} else {
respond(response, 400, "Bad request.");
}
}).listen(1337, '0.0.0.0');
```
|
```objective-c
// This is a part of the Active Template Library.
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef __ATLTRANSACTIONMANAGER_H__
#define __ATLTRANSACTIONMANAGER_H__
#pragma once
#include <atldef.h>
#if !defined(_ATL_USE_WINAPI_FAMILY_DESKTOP_APP)
#error This file is not compatible with the current WINAPI_FAMILY
#endif
#include <ktmw32.h>
#include <tchar.h>
extern "C" _VCRTIMP bool __cdecl __uncaught_exception();
#pragma pack(push,_ATL_PACKING)
namespace ATL
{
/// <summary>
/// CAtlTransactionManager class provides a wrapper to Kernel Transaction Manager (KTM) functions.</summary>
class CAtlTransactionManager
{
public:
/// <summary>
/// CAtlTransactionManager constructor</summary>
/// <param name="bFallback">TRUE - support fallback. If transacted function fails, the class automatically calls the "non-transacted" function. FALSE - no "fallback" calls.</param>
/// <param name="bAutoCreateTransaction">TRUE - auto-create transaction handler in constructor. FALSE - don't create</param>
explicit CAtlTransactionManager(_In_ BOOL bFallback = TRUE, _In_ BOOL bAutoCreateTransaction = TRUE) :
m_hTransaction(NULL), m_bFallback(bFallback)
{
if (bAutoCreateTransaction)
{
Create();
}
}
/// <summary>
/// CAtlTransactionManager destructor. In normal processing, the transaction is automatically committed and closed. If the destructor is called during an exception unwind, the transaction is rolled back and closed.</summary>
~CAtlTransactionManager()
{
if (m_hTransaction != NULL)
{
if (__uncaught_exception())
{
Rollback();
}
else
{
Commit();
}
Close();
}
}
private:
// Copy construction and copy are not supported, so make sure that the compiler does not generate
// implicit versions and that a compiler error is issued if someone attempts to use them.
CAtlTransactionManager(_In_ const CAtlTransactionManager &atm);
CAtlTransactionManager &operator=(_In_ const CAtlTransactionManager &atm);
// Attributes:
public:
/// <summary>
/// Returns transaction handle</summary>
/// <returns>
/// Returns the transaction handle for a class. Returns NULL if the CAtlTransactionManager is not attached to a handle.</returns>
HANDLE GetHandle() const
{
return m_hTransaction;
}
/// <summary>
/// Determines whether the fallback calls are enabled </summary>
/// <returns>
/// Returns TRUE is the class support fallback calls. FALSE - otherwise.</returns>
BOOL IsFallback() const
{
return m_bFallback;
}
// Operattions:
public:
/// <summary>
/// Creates transaction handle. This wrapper calls Windows CreateTransaction function</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
BOOL Create();
/// <summary>
/// Closes transaction handle. This wrapper calls Windows CloseHandle function. The method is automatically called in destructor</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
BOOL Close();
/// <summary>
/// Requests that the transaction be committed. This wrapper calls Windows CommitTransaction function. The method is automatically called in destructor.</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
BOOL Commit();
/// <summary>
/// Requests that the transaction be rolled back. This wrapper calls Windows RollbackTransaction function</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
BOOL Rollback();
/// <summary>
/// Creates or opens a file, file stream, or directory as a transacted operation. This wrapper calls Windows CreateFileTransacted function</summary>
/// <returns>
/// Returns a handle that can be used to access the object.</returns>
/// <param name="lpFileName">The name of an object to be created or opened.</param>
/// <param name="dwDesiredAccess">The access to the object, which can be summarized as read, write, both or neither (zero). The most commonly used values are GENERIC_READ, GENERIC_WRITE, or both (GENERIC_READ | GENERIC_WRITE).</param>
/// <param name="dwShareMode">The sharing mode of an object, which can be read, write, both, delete, all of these, or none: 0, FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE</param>
/// <param name="lpSecurityAttributes">A pointer to a SECURITY_ATTRIBUTES structure that contains an optional security descriptor and also determines whether or not the returned handle can be inherited by child processes. The parameter can be NULL</param>
/// <param name="dwCreationDisposition">An action to take on files that exist and do not exist. This parameter must be one of the following values, which cannot be combined: CREATE_ALWAYS, CREATE_NEW, OPEN_ALWAYS, OPEN_EXISTING or TRUNCATE_EXISTING</param>
/// <param name="dwFlagsAndAttributes">The file attributes and flags. This parameter can include any combination of the available file attributes (FILE_ATTRIBUTE_*). All other file attributes override FILE_ATTRIBUTE_NORMAL. This parameter can also contain combinations of flags (FILE_FLAG_*) for control of buffering behavior, access modes, and other special-purpose flags. These combine with any FILE_ATTRIBUTE_* values.</param>
/// <param name="hTemplateFile">A valid handle to a template file with the GENERIC_READ access right. The template file supplies file attributes and extended attributes for the file that is being created. This parameter can be NULL.</param>
HANDLE CreateFile(
_In_z_ LPCTSTR lpFileName,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwShareMode,
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_In_ DWORD dwCreationDisposition,
_In_ DWORD dwFlagsAndAttributes,
_In_opt_ HANDLE hTemplateFile);
/// <summary>
/// Deletes an existing file as a transacted operation. This wrapper calls Windows DeleteFileTransacted function</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
/// <param name="lpFileName">The name of the file to be deleted.</param>
BOOL DeleteFile(_In_z_ LPCTSTR lpFileName);
/// <summary>
/// Moves an existing file or a directory, including its children, as a transacted operation. This wrapper calls Windows MoveFileTransacted function</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
/// <param name="lpOldFileName">The current name of the existing file or directory on the local computer.</param>
/// <param name="lpNewFileName">The new name for the file or directory. The new name must not already exist. A new file may be on a different file system or drive. A new directory must be on the same drive.</param>
BOOL MoveFile(
_In_z_ LPCTSTR lpOldFileName,
_In_z_ LPCTSTR lpNewFileName);
/// <summary>
/// Retrieves file system attributes for a specified file or directory as a transacted operation. This wrapper calls Windows GetFileAttributesTransacted function</summary>
/// <returns>
/// File attributes (see WIN32_FILE_ATTRIBUTE_DATA::dwFileAttributes desciption).</returns>
/// <param name="lpFileName">The name of the file or directory.</param>
DWORD GetFileAttributes(_In_z_ LPCTSTR lpFileName);
/// <summary>
/// Retrieves file system attributes for a specified file or directory as a transacted operation. This wrapper calls Windows GetFileAttributesTransacted function</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
/// <param name="lpFileName">The name of the file or directory.</param>
/// <param name="fInfoLevelId">The level of attribute information to retrieve.</param>
/// <param name="lpFileInformation">A pointer to a buffer that receives the attribute information. The type of attribute information that is stored into this buffer is determined by the value of fInfoLevelId. If the fInfoLevelId parameter is GetFileExInfoStandard then this parameter points to a WIN32_FILE_ATTRIBUTE_DATA structure.</param>
_Success_(return != FALSE) BOOL GetFileAttributesEx(
_In_z_ LPCTSTR lpFileName,
_In_ GET_FILEEX_INFO_LEVELS fInfoLevelId,
_Out_opt_ LPVOID lpFileInformation);
/// <summary>
/// Sets the attributes for a file or directory as a transacted operation. This wrapper calls Windows SetFileAttributesTransacted function</summary>
/// <returns>
/// TRUE if succeeds; otherwise FALSE.</returns>
/// <param name="lpFileName">The name of the file or directory.</param>
/// <param name="dwAttributes">The file attributes to set for the file. See SetFileAttributesTransacted function description</param>
BOOL SetFileAttributes(
_In_z_ LPCTSTR lpFileName,
_In_ DWORD dwAttributes);
/// <summary>
/// Searches a directory for a file or subdirectory with a name that matches a specific name as a transacted operation. This wrapper calls Windows FindFirstFileTransacted function</summary>
/// <returns>
/// If the function succeeds, the return value is a search handle used in a subsequent call to FindNextFile or FindClose. If the function fails or fails to locate files from the search string in the lpFileName parameter, the return value is INVALID_HANDLE_VALUE.</returns>
/// <param name="lpFileName">The directory or path, and the file name, which can include wildcard characters, for example, an asterisk (*) or a question mark (?).</param>
/// <param name="pNextInfo">A pointer to the WIN32_FIND_DATA structure that receives information about a found file or subdirectory.</param>
_Success_(return != INVALID_HANDLE_VALUE) HANDLE FindFirstFile(
_In_z_ LPCTSTR lpFileName,
_Out_opt_ WIN32_FIND_DATA* pNextInfo);
/// <summary>
/// Creates the specified registry key and associates it with a transaction. If the key already exists, the function opens it. This wrapper calls Windows RegCreateKeyTransacted function</summary>
/// <returns>
/// If the function succeeds, the return value is ERROR_SUCCESS. If the function fails, the return value is a nonzero error code defined in Winerror.h</returns>
/// <param name="hKey">A handle to an open registry key.</param>
/// <param name="lpSubKey">The name of a subkey that this function opens or creates.</param>
/// <param name="dwReserved">This parameter is reserved and must be zero</param>
/// <param name="ulOptions">This parameter can be one of the following values: REG_OPTION_BACKUP_RESTORE, REG_OPTION_NON_VOLATILE or REG_OPTION_VOLATILE.</param>
/// <param name="samDesired">A mask that specifies the access rights for the key</param>
/// <param name="lpSecurityAttributes"> pointer to a SECURITY_ATTRIBUTES structure that determines whether the returned handle can be inherited by child processes. If lpSecurityAttributes is NULL, the handle cannot be inherited</param>
/// <param name="phkResult">A pointer to a variable that receives a handle to the opened or created key. If the key is not one of the predefined registry keys, call the RegCloseKey function after you have finished using the handle</param>
/// <param name="lpdwDisposition">A pointer to a variable that receives one of the following disposition values: REG_CREATED_NEW_KEY or REG_OPENED_EXISTING_KEY</param>
LSTATUS RegCreateKeyEx(
_In_ HKEY hKey,
_In_z_ LPCTSTR lpSubKey,
_Reserved_ DWORD dwReserved,
_In_opt_z_ LPTSTR lpClass,
_In_ DWORD dwOptions,
_In_ REGSAM samDesired,
_In_opt_ CONST LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_Out_ PHKEY phkResult,
_Out_opt_ LPDWORD lpdwDisposition);
/// <summary>
/// Opens the specified registry key and associates it with a transaction. This wrapper calls Windows RegOpenKeyTransacted function</summary>
/// <returns>
/// If the function succeeds, the return value is ERROR_SUCCESS. If the function fails, the return value is a nonzero error code defined in Winerror.h</returns>
/// <param name="hKey">A handle to an open registry key.</param>
/// <param name="lpSubKey">The name of the registry subkey to be opened.</param>
/// <param name="ulOptions">This parameter is reserved and must be zero.</param>
/// <param name="samDesired">A mask that specifies the access rights for the key</param>
/// <param name="phkResult">A pointer to a variable that receives a handle to the opened or created key. If the key is not one of the predefined registry keys, call the RegCloseKey function after you have finished using the handle</param>
LSTATUS RegOpenKeyEx(
_In_ HKEY hKey,
_In_opt_z_ LPCTSTR lpSubKey,
_In_ DWORD ulOptions,
_In_ REGSAM samDesired,
_Out_ PHKEY phkResult);
/// <summary>
/// Deletes a subkey and its values from the specified platform-specific view of the registry as a transacted operation. This wrapper calls Windows RegDeleteKeyTransacted function</summary>
/// <returns>
/// If the function succeeds, the return value is ERROR_SUCCESS. If the function fails, the return value is a nonzero error code defined in Winerror.h</returns>
/// <param name="hKey">A handle to an open registry key.</param>
/// <param name="lpSubKey">The name of the key to be deleted.</param>
LSTATUS RegDeleteKey(
_In_ HKEY hKey,
_In_z_ LPCTSTR lpSubKey);
protected:
/// <summary>
/// Transaction handle</summary>
HANDLE m_hTransaction;
/// <summary>
/// TRUE: if the fallback is supported; FALSE - otherwise.</summary>
BOOL m_bFallback;
};
inline BOOL CAtlTransactionManager::Create()
{
if (m_hTransaction != NULL)
{
// Already created
ATLASSERT(FALSE);
return FALSE;
}
typedef HANDLE (WINAPI* PFNCREATETRANSACTION)(LPSECURITY_ATTRIBUTES, LPGUID, DWORD, DWORD, DWORD, DWORD, LPWSTR);
static bool bInitialized = false;
static PFNCREATETRANSACTION pfCreateTransaction = NULL;
if (!bInitialized)
{
HMODULE hKTM32 = AtlLoadSystemLibraryUsingFullPath(L"ktmw32.dll");
if (hKTM32 != NULL)
{
pfCreateTransaction = (PFNCREATETRANSACTION)GetProcAddress(hKTM32, "CreateTransaction");
}
bInitialized = true;
}
if (pfCreateTransaction == NULL)
{
return FALSE;
}
SECURITY_ATTRIBUTES sa;
ZeroMemory(&sa, sizeof(SECURITY_ATTRIBUTES));
m_hTransaction = (*pfCreateTransaction)(&sa, 0, 0, 0, 0, 0, NULL);
return m_hTransaction != NULL;
}
inline BOOL CAtlTransactionManager::Close()
{
if (m_hTransaction == NULL)
{
return FALSE;
}
if (!::CloseHandle(m_hTransaction))
{
return FALSE;
}
m_hTransaction = NULL;
return TRUE;
}
inline BOOL CAtlTransactionManager::Commit()
{
if (m_hTransaction == NULL)
{
ATLASSERT(FALSE);
return FALSE;
}
typedef BOOL (WINAPI* PFNCOMMITTRANSACTION)(HANDLE);
static bool bInitialized = false;
static PFNCOMMITTRANSACTION pfCommitTransaction = NULL;
if (!bInitialized)
{
HMODULE hKTM32 = AtlLoadSystemLibraryUsingFullPath(L"ktmw32.dll");
if (hKTM32 != NULL)
{
pfCommitTransaction = (PFNCOMMITTRANSACTION)GetProcAddress(hKTM32, "CommitTransaction");
}
bInitialized = true;
}
if (pfCommitTransaction != NULL)
{
return (*pfCommitTransaction)(m_hTransaction);
}
return FALSE;
}
inline BOOL CAtlTransactionManager::Rollback()
{
if (m_hTransaction == NULL)
{
ATLASSERT(FALSE);
return FALSE;
}
typedef BOOL (WINAPI* PFNROLLBACKTRANSACTION)(HANDLE);
static bool bInitialized = false;
static PFNROLLBACKTRANSACTION pfRollbackTransaction = NULL;
if (!bInitialized)
{
HMODULE hKTM32 = AtlLoadSystemLibraryUsingFullPath(L"ktmw32.dll");
if (hKTM32 != NULL)
{
pfRollbackTransaction = (PFNROLLBACKTRANSACTION)GetProcAddress(hKTM32, "RollbackTransaction");
}
bInitialized = true;
}
if (pfRollbackTransaction != NULL)
{
return (*pfRollbackTransaction)(m_hTransaction);
}
return FALSE;
}
inline HANDLE CAtlTransactionManager::CreateFile(
_In_z_ LPCTSTR lpFileName,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwShareMode,
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_In_ DWORD dwCreationDisposition,
_In_ DWORD dwFlagsAndAttributes,
_In_opt_ HANDLE hTemplateFile)
{
if (m_hTransaction != NULL)
{
HMODULE hKernel32 = ::GetModuleHandle(_T("kernel32.dll"));
ATLASSERT(hKernel32 != NULL);
if (hKernel32 == NULL)
{
return INVALID_HANDLE_VALUE;
}
#ifdef _UNICODE
typedef HANDLE (WINAPI* PFNCREATEFILETRANSACTED)(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE, HANDLE, PUSHORT, PVOID);
PFNCREATEFILETRANSACTED pfCreateTransacted = (PFNCREATEFILETRANSACTED)GetProcAddress(hKernel32, "CreateFileTransactedW");
#else
typedef HANDLE (WINAPI* PFNCREATEFILETRANSACTED)(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE, HANDLE, PUSHORT, PVOID);
PFNCREATEFILETRANSACTED pfCreateTransacted = (PFNCREATEFILETRANSACTED)GetProcAddress(hKernel32, "CreateFileTransactedA");
#endif
if (pfCreateTransacted != NULL)
{
return (*pfCreateTransacted)(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, m_hTransaction, NULL, NULL);
}
}
else if (m_bFallback)
{
return ::CreateFile((LPCTSTR)lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, NULL);
}
return INVALID_HANDLE_VALUE;
}
inline BOOL CAtlTransactionManager::DeleteFile(_In_z_ LPCTSTR lpFileName)
{
if (m_hTransaction != NULL)
{
HMODULE hKernel32 = ::GetModuleHandle(_T("kernel32.dll"));
ATLASSERT(hKernel32 != NULL);
if (hKernel32 == NULL)
{
return FALSE;
}
#ifdef _UNICODE
typedef BOOL (WINAPI* PFNDELETEFILETRANSACTED)(LPCWSTR, HANDLE);
PFNDELETEFILETRANSACTED pfDeleteTransacted = (PFNDELETEFILETRANSACTED)GetProcAddress(hKernel32, "DeleteFileTransactedW");
#else
typedef BOOL (WINAPI* PFNDELETEFILETRANSACTED)(LPCSTR, HANDLE);
PFNDELETEFILETRANSACTED pfDeleteTransacted = (PFNDELETEFILETRANSACTED)GetProcAddress(hKernel32, "DeleteFileTransactedA");
#endif
if (pfDeleteTransacted != NULL)
{
return (*pfDeleteTransacted)(lpFileName, m_hTransaction);
}
}
else if (m_bFallback)
{
return ::DeleteFile((LPTSTR)lpFileName);
}
return FALSE;
}
inline BOOL CAtlTransactionManager::MoveFile(
_In_z_ LPCTSTR lpOldFileName,
_In_z_ LPCTSTR lpNewFileName)
{
if (m_hTransaction != NULL)
{
HMODULE hKernel32 = ::GetModuleHandle(_T("kernel32.dll"));
ATLASSERT(hKernel32 != NULL);
if (hKernel32 == NULL)
{
return FALSE;
}
#ifdef _UNICODE
typedef BOOL (WINAPI* PFNMOVEFILETRANSACTED)(LPCWSTR, LPCWSTR, LPPROGRESS_ROUTINE, LPVOID, DWORD, HANDLE);
PFNMOVEFILETRANSACTED pfMoveFileTransacted = (PFNMOVEFILETRANSACTED)GetProcAddress(hKernel32, "MoveFileTransactedW");
#else
typedef BOOL (WINAPI* PFNMOVEFILETRANSACTED)(LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, DWORD, HANDLE);
PFNMOVEFILETRANSACTED pfMoveFileTransacted = (PFNMOVEFILETRANSACTED)GetProcAddress(hKernel32, "MoveFileTransactedA");
#endif
if (pfMoveFileTransacted != NULL)
{
return (*pfMoveFileTransacted)(lpOldFileName, lpNewFileName, NULL, NULL, MOVEFILE_COPY_ALLOWED, m_hTransaction);
}
}
else if (m_bFallback)
{
return ::MoveFile(lpOldFileName, lpNewFileName);
}
return FALSE;
}
inline _Success_(return != FALSE) BOOL CAtlTransactionManager::GetFileAttributesEx(
_In_z_ LPCTSTR lpFileName,
_In_ GET_FILEEX_INFO_LEVELS fInfoLevelId,
_Out_opt_ LPVOID lpFileInformation)
{
if (lpFileInformation == NULL)
{
return FALSE;
}
if (m_hTransaction != NULL)
{
HMODULE hKernel32 = ::GetModuleHandle(_T("kernel32.dll"));
ATLASSERT(hKernel32 != NULL);
if (hKernel32 == NULL)
{
return FALSE;
}
#ifdef _UNICODE
typedef BOOL (WINAPI* PFNGETFILEATTRIBUTESTRANSACTED)(LPCWSTR, GET_FILEEX_INFO_LEVELS, LPVOID, HANDLE);
PFNGETFILEATTRIBUTESTRANSACTED pfGetFileAttributesTransacted = (PFNGETFILEATTRIBUTESTRANSACTED)GetProcAddress(hKernel32, "GetFileAttributesTransactedW");
#else
typedef BOOL (WINAPI* PFNGETFILEATTRIBUTESTRANSACTED)(LPCSTR, GET_FILEEX_INFO_LEVELS, LPVOID, HANDLE);
PFNGETFILEATTRIBUTESTRANSACTED pfGetFileAttributesTransacted = (PFNGETFILEATTRIBUTESTRANSACTED)GetProcAddress(hKernel32, "GetFileAttributesTransactedA");
#endif
if (pfGetFileAttributesTransacted != NULL)
{
return (*pfGetFileAttributesTransacted)(lpFileName, fInfoLevelId, lpFileInformation, m_hTransaction);
}
}
else if (m_bFallback)
{
return ::GetFileAttributesEx((LPCTSTR)lpFileName, fInfoLevelId, lpFileInformation);
}
return FALSE;
}
inline DWORD CAtlTransactionManager::GetFileAttributes(_In_z_ LPCTSTR lpFileName)
{
WIN32_FILE_ATTRIBUTE_DATA fileAttributeData;
if (GetFileAttributesEx(lpFileName, GetFileExInfoStandard, &fileAttributeData))
{
return fileAttributeData.dwFileAttributes;
}
return 0;
}
inline BOOL CAtlTransactionManager::SetFileAttributes(
_In_z_ LPCTSTR lpFileName,
_In_ DWORD dwAttributes)
{
if (m_hTransaction != NULL)
{
HMODULE hKernel32 = ::GetModuleHandle(_T("kernel32.dll"));
ATLASSERT(hKernel32 != NULL);
if (hKernel32 == NULL)
{
return FALSE;
}
#ifdef _UNICODE
typedef BOOL (WINAPI* PFNSETFILEATTRIBUTESTRANSACTED)(LPCWSTR, DWORD, HANDLE);
PFNSETFILEATTRIBUTESTRANSACTED pfSetFileAttributesTransacted = (PFNSETFILEATTRIBUTESTRANSACTED)GetProcAddress(hKernel32, "SetFileAttributesTransactedW");
#else
typedef BOOL (WINAPI* PFNSETFILEATTRIBUTESTRANSACTED)(LPCSTR, DWORD, HANDLE);
PFNSETFILEATTRIBUTESTRANSACTED pfSetFileAttributesTransacted = (PFNSETFILEATTRIBUTESTRANSACTED)GetProcAddress(hKernel32, "SetFileAttributesTransactedA");
#endif
if (pfSetFileAttributesTransacted != NULL)
{
return (*pfSetFileAttributesTransacted)(lpFileName, dwAttributes, m_hTransaction);
}
}
else if (m_bFallback)
{
return ::SetFileAttributes((LPCTSTR)lpFileName, dwAttributes);
}
return FALSE;
}
inline _Success_(return != INVALID_HANDLE_VALUE) HANDLE CAtlTransactionManager::FindFirstFile(
_In_z_ LPCTSTR lpFileName,
_Out_opt_ WIN32_FIND_DATA* pNextInfo)
{
if (pNextInfo == NULL)
{
return INVALID_HANDLE_VALUE;
}
if (m_hTransaction != NULL)
{
HMODULE hKernel32 = ::GetModuleHandle(_T("kernel32.dll"));
ATLASSERT(hKernel32 != NULL);
if (hKernel32 == NULL)
{
return INVALID_HANDLE_VALUE;
}
#ifdef _UNICODE
typedef HANDLE (WINAPI* PFNFINDFIRSTFILETRANSACTED)(LPCWSTR, FINDEX_INFO_LEVELS, LPVOID, FINDEX_SEARCH_OPS, LPVOID, DWORD, HANDLE);
PFNFINDFIRSTFILETRANSACTED pfFindFirstFileTransacted = (PFNFINDFIRSTFILETRANSACTED)GetProcAddress(hKernel32, "FindFirstFileTransactedW");
#else
typedef HANDLE (WINAPI* PFNFINDFIRSTFILETRANSACTED)(LPCSTR, FINDEX_INFO_LEVELS, LPVOID, FINDEX_SEARCH_OPS, LPVOID, DWORD, HANDLE);
PFNFINDFIRSTFILETRANSACTED pfFindFirstFileTransacted = (PFNFINDFIRSTFILETRANSACTED)GetProcAddress(hKernel32, "FindFirstFileTransactedA");
#endif
if (pfFindFirstFileTransacted != NULL)
{
return (*pfFindFirstFileTransacted)(lpFileName, FindExInfoStandard, pNextInfo, FindExSearchNameMatch, NULL, 0, m_hTransaction);
}
}
else if (m_bFallback)
{
return ::FindFirstFile(lpFileName, pNextInfo);
}
return INVALID_HANDLE_VALUE;
}
inline LSTATUS CAtlTransactionManager::RegOpenKeyEx(
_In_ HKEY hKey,
_In_opt_z_ LPCTSTR lpSubKey,
_In_ DWORD ulOptions,
_In_ REGSAM samDesired,
_Out_ PHKEY phkResult)
{
if (m_hTransaction != NULL)
{
HMODULE hAdvAPI32 = ::GetModuleHandle(_T("Advapi32.dll"));
ATLASSERT(hAdvAPI32 != NULL);
if (hAdvAPI32 == NULL)
{
return ERROR_INVALID_FUNCTION;
}
#ifdef _UNICODE
typedef LSTATUS (WINAPI* PFNREGOPENKEYTRANSACTED)(HKEY, LPCWSTR, DWORD, REGSAM, PHKEY, HANDLE, PVOID);
PFNREGOPENKEYTRANSACTED pfRegOpenKeyTransacted = (PFNREGOPENKEYTRANSACTED)GetProcAddress(hAdvAPI32, "RegOpenKeyTransactedW");
#else
typedef LSTATUS (WINAPI* PFNREGOPENKEYTRANSACTED)(HKEY, LPCSTR, DWORD, REGSAM, PHKEY, HANDLE, PVOID);
PFNREGOPENKEYTRANSACTED pfRegOpenKeyTransacted = (PFNREGOPENKEYTRANSACTED)GetProcAddress(hAdvAPI32, "RegOpenKeyTransactedA");
#endif
if (pfRegOpenKeyTransacted != NULL)
{
return (*pfRegOpenKeyTransacted)(hKey, lpSubKey, ulOptions, samDesired, phkResult, m_hTransaction, NULL);
}
}
else if (m_bFallback)
{
return ::RegOpenKeyEx(hKey, lpSubKey, ulOptions, samDesired, phkResult);
}
return ERROR_INVALID_FUNCTION;
}
inline LSTATUS CAtlTransactionManager::RegCreateKeyEx(
_In_ HKEY hKey,
_In_z_ LPCTSTR lpSubKey,
_Reserved_ DWORD dwReserved,
_In_opt_z_ LPTSTR lpClass,
_In_ DWORD dwOptions,
_In_ REGSAM samDesired,
_In_opt_ CONST LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_Out_ PHKEY phkResult,
_Out_opt_ LPDWORD lpdwDisposition)
{
if (m_hTransaction != NULL)
{
HMODULE hAdvAPI32 = ::GetModuleHandle(_T("Advapi32.dll"));
ATLASSERT(hAdvAPI32 != NULL);
if (hAdvAPI32 == NULL)
{
return ERROR_INVALID_FUNCTION;
}
#ifdef _UNICODE
typedef LSTATUS (WINAPI* PFNREGCREATEKEYTRANSACTED)(HKEY, LPCWSTR, DWORD, LPWSTR, DWORD, REGSAM, CONST LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD, HANDLE, PVOID);
PFNREGCREATEKEYTRANSACTED pfRegCreateKeyTransacted = (PFNREGCREATEKEYTRANSACTED)GetProcAddress(hAdvAPI32, "RegCreateKeyTransactedW");
#else
typedef LSTATUS (WINAPI* PFNREGCREATEKEYTRANSACTED)(HKEY, LPCSTR, DWORD, LPSTR, DWORD, REGSAM, CONST LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD, HANDLE, PVOID);
PFNREGCREATEKEYTRANSACTED pfRegCreateKeyTransacted = (PFNREGCREATEKEYTRANSACTED)GetProcAddress(hAdvAPI32, "RegCreateKeyTransactedA");
#endif
if (pfRegCreateKeyTransacted != NULL)
{
return (*pfRegCreateKeyTransacted)(hKey, lpSubKey, dwReserved, lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition, m_hTransaction, NULL);
}
}
else if (m_bFallback)
{
return ::RegCreateKeyEx(hKey, lpSubKey, dwReserved, lpClass, dwOptions, samDesired, lpSecurityAttributes, phkResult, lpdwDisposition);
}
return ERROR_INVALID_FUNCTION;
}
inline LSTATUS CAtlTransactionManager::RegDeleteKey(_In_ HKEY hKey, _In_z_ LPCTSTR lpSubKey)
{
if (m_hTransaction != NULL)
{
HMODULE hAdvAPI32 = ::GetModuleHandle(_T("Advapi32.dll"));
ATLASSERT(hAdvAPI32 != NULL);
if (hAdvAPI32 == NULL)
{
return ERROR_INVALID_FUNCTION;
}
#ifdef _UNICODE
typedef LSTATUS (WINAPI* PFNREGDELETEKEYTRANSACTED)(HKEY, LPCWSTR, REGSAM, DWORD, HANDLE, PVOID);
PFNREGDELETEKEYTRANSACTED pfRegDeleteKeyTransacted = (PFNREGDELETEKEYTRANSACTED)GetProcAddress(hAdvAPI32, "RegDeleteKeyTransactedW");
#else
typedef LSTATUS (WINAPI* PFNREGDELETEKEYTRANSACTED)(HKEY, LPCSTR, REGSAM, DWORD, HANDLE, PVOID);
PFNREGDELETEKEYTRANSACTED pfRegDeleteKeyTransacted = (PFNREGDELETEKEYTRANSACTED)GetProcAddress(hAdvAPI32, "RegDeleteKeyTransactedA");
#endif
if (pfRegDeleteKeyTransacted != NULL)
{
return (*pfRegDeleteKeyTransacted)(hKey, lpSubKey, 0, 0, m_hTransaction, NULL);
}
}
else if (m_bFallback)
{
return ::RegDeleteKey(hKey, lpSubKey);
}
return ERROR_INVALID_FUNCTION;
}
} //namespace ATL
#pragma pack(pop)
#endif // __ATLTRANSACTIONMANAGER_H__
```
|
```objective-c
//===- CoverageExporterLcov.h - Code coverage lcov exporter ---------------===//
//
// See path_to_url for license information.
//
//===your_sha256_hash------===//
//
// This class implements a code coverage exporter for lcov trace file format.
//
//===your_sha256_hash------===//
#ifndef LLVM_COV_COVERAGEEXPORTERLCOV_H
#define LLVM_COV_COVERAGEEXPORTERLCOV_H
#include "CoverageExporter.h"
namespace llvm {
class CoverageExporterLcov : public CoverageExporter {
public:
CoverageExporterLcov(const coverage::CoverageMapping &CoverageMapping,
const CoverageViewOptions &Options, raw_ostream &OS)
: CoverageExporter(CoverageMapping, Options, OS) {}
/// Render the CoverageMapping object.
void renderRoot(const CoverageFilters &IgnoreFilters) override;
/// Render the CoverageMapping object for specified source files.
void renderRoot(ArrayRef<std::string> SourceFiles) override;
};
} // end namespace llvm
#endif // LLVM_COV_COVERAGEEXPORTERLCOV_H
```
|
Simon James Wright (born 15 September 1979) is a former British Liberal Democrat politician, who served as the Member of Parliament for Norwich South from 2010 to 2015. Wright defeated frontbench incumbent Charles Clarke (Labour), winning 29.7% of the votes and a narrow majority of 310 votes. He is now chief executive officer of a Norfolk-based charity, Nelson's Journey.
Early life
Wright was educated at Dereham Neatherd High School. He attended Imperial College London, receiving a BSc in Maths, and King's College London, receiving a PGCE. He has worked as a maths teacher at Alderman Peel High School in Wells-next-the-Sea in North Norfolk.
Political career
Wright was elected as a councillor for the Lancaster North ward (Fakenham) on North Norfolk District Council in 2003. Wright achieved the second-highest percentage of the vote of two seats available in the poll behind Cllr Nich Starling (LD).
Later that year, Wright quit his job as a teacher to become campaigns officer for Norman Lamb, Liberal Democrat MP for North Norfolk. In 2005, Wright oversaw Norman Lamb's successful re-election campaign in North Norfolk, which increased his majority from 483 votes to 10,606.
Wright stepped down as campaigns officer in 2007 to devote himself full-time to being the Liberal Democrat prospective parliamentary candidate for Norwich South.
Wright's first parliamentary appointment saw him appointed to the Environmental Audit Select Committee in July 2010.
He lost his seat at the 2015 general election, when he finished in fourth place behind the Green, Conservative and Labour Party candidates.
Personal life
Simon Wright worked as campaigns officer for Norman Lamb MP. The member of staff whom Wright replaced in that role became his wife in 2006.
After losing his parliamentary seat in 2015, Simon became chief executive officer of a children's bereavement charity called Nelson's Journey in Norfolk in June 2016.
In 2019 Simon got re-married to fellow runner Anna Thorpe, making headlines for taking part in the weekly parkrun with other guests before the ceremony.
References
External links
1979 births
Living people
Liberal Democrats (UK) MPs for English constituencies
UK MPs 2010–2015
Alumni of Imperial College London
Alumni of King's College London
Councillors in Norfolk
Liberal Democrats (UK) councillors
|
```css
.menu-mobile .menu-section.on {
z-index: 10;
width: 100%;
height: 100%;
top: 0;
left: 0;
right: 0;
bottom: 0;
position:fixed;
background-color: rgba(55, 61, 73, 0.9);
overflow:scroll;
}
.menu-mobile .menu-toggle {
width: 30px;
height: 30px;
position: absolute;
top: 40px;
right: 25px;
cursor: pointer;
z-index: 11;
}
.menu-toggle.on{
position:fixed;
}
.menu-mobile .menu-toggle.on .one {
-moz-transform: rotate(45deg) translate(7px, 7px);
-ms-transform: rotate(45deg) translate(7px, 7px);
-webkit-transform: rotate(45deg) translate(7px, 7px);
transform: rotate(45deg) translate(7px, 7px);
}
.menu-mobile .menu-toggle.on .two {
opacity: 0;
}
.menu-mobile .menu-toggle.on .three {
-moz-transform: rotate(-45deg) translate(7px, -8px);
-ms-transform: rotate(-45deg) translate(7px, -8px);
-webkit-transform: rotate(-45deg) translate(7px, -8px);
transform: rotate(-45deg) translate(7px, -8px);
}
.menu-mobile .one,
.menu-mobile .two,
.menu-mobile .three {
width: 100%;
height: 4px;
background: white;
margin: 6px auto;
backface-visibility: hidden;
-moz-transition-duration: 0.3s;
-o-transition-duration: 0.3s;
-webkit-transition-duration: 0.3s;
transition-duration: 0.3s;
}
.menu-mobile .menu-toggle:hover .one,
.menu-mobile .menu-toggle:hover .two,
.menu-mobile .menu-toggle:hover .three{
background: #C64087;
}
.menu-mobile nav ul {
margin: 0;
padding: 0;
list-style: none;
margin: 12em auto;
text-align: center;
}
.menu-mobile nav ul.hidden {
display: none;
}
.menu-mobile nav ul a {
-moz-transition-duration: 0.5s;
-o-transition-duration: 0.5s;
-webkit-transition-duration: 0.5s;
transition-duration: 0.5s;
text-decoration: none !important;
color: white;
width: 100%;
display: block;
}
@media (min-width: 670px) {
.menu-mobile nav ul a {
font-size: 1.5em;
line-height: 1.5;
}
.menu-mobile nav ul {
margin: 8em auto;
}
.menu-mobile .menu-toggle::before {
content: "Explore";
position: absolute;
left: -70px;
top: 4px;
color: #fff;
}
.menu-mobile .menu-toggle.on::before{
content: "Close";
left: -60px;
}
}
@media (min-width: 960px) {
.menu-mobile nav ul a {
font-size: 2.0em;
line-height: 1.5;
}
}
.menu-mobile nav ul a:hover, .menu-mobile nav ul li a.active {
background-color: #C64087;
color:#fff;
}
```
|
On 7 December 1985 the Provisional Irish Republican Army (IRA) attacked the Royal Ulster Constabulary (RUC) base at Ballygawley, County Tyrone. Two RUC officers were shot dead and the base was raked with gunfire before being destroyed by a bomb, which wounded a further three officers.
Background
In 1985, Patrick Kelly became leader of the Provisional IRA East Tyrone Brigade. He, along with East Tyrone Brigade members Jim Lynagh and Pádraig McKearney, advocated using flying columns to destroy isolated British Army and RUC bases and stop them from being repaired. The goal was to create and hold "liberated zones" under IRA control that would be gradually enlarged. Although IRA Chief of Staff Kevin McKenna turned-down the flying column idea, IRA Northern Command approved the plan to destroy bases and prevent their repair. In that year alone there were 44 such attacks. Among the most devastating was the mortar attack on Newry RUC barracks in March.
The attack
The attack involved two IRA active service units from the East Tyrone Brigade: an armed assault unit and a bomb unit. There were also several teams of IRA observers in the area. The assault team was armed with AK-47 and AR-15 rifles, while the bombing unit was to be responsible for planting and detonating a bomb. Both units were commanded by Patrick Kelly.
The assault was launched on Saturday 7 December at 18:55, when the handful of RUC officers manning the base were getting ready to hand over to the next shift. In the first burst of automatic fire, the two guards at the entrance were killed: Constable George Gilliland and Reserve Constable William Clements. Constable Clements' Ruger Speed-Six revolver was taken by the attackers. The base was then raked with gunfire. Another three RUC officers who were inside ran out to the back of the base, where they hoped the walls might offer some cover. IRA members went into the building and took documents and weapons. The bomb was placed inside and, upon detonation, destroyed the entire base. Three officers were hurt.
The republican IRIS Magazine (#11, October 1987) described the attack as follows:One volunteer took up a position close to the front gate. Two RUC men opened the gate and the volunteer calmly stepped forward, shooting them both dead at point blank range. Volunteers firing AK-47 and Armalite rifles moved into the barracks, raking it with gunfire. Having secured the building they planted a 100 lb bomb inside. The bomb exploded, totally destroying the building after the volunteers had withdrawn to safety.
The first British Army unit to arrive at the base in the wake of the attack was X Company, 1st Battalion, Royal Regiment of Fusiliers.
Aftermath
The attack was one of the Provisional IRA's biggest during this period. Twelve days later the same IRA brigade mortared the RUC station at Castlederg badly damaging the base and injuring four people. The Ballygawley base was rebuilt by the Royal Engineers in 1986.
The East Tyrone IRA launched two similar attacks in the following years: the successful attack on the Birches base in 1986, and the ill-fated attack on the Loughgall base in 1987, in which eight IRA members were killed. Ballygawley itself had seen conflict before with the Ballygawley land mine attack in 1983, and would see more violence in 1988 with the Ballygawley bus bombing, that cost the lives of eight British soldiers. The gun taken from Constable Clements was found by security forces after the SAS ambush at Loughgall.
The RUC base at Ballygawley was once again targeted by the East Tyrone Brigade on 7 December 1992, in what became the debut of the IRA's brand new Mark-15 improvised mortar, better known as "Barrack Buster". Another attack with a horizontal mortar occurred on 30 April 1993, when an RUC mobile patrol leaving Ballygawley compound was targeted. According to an IRA statement, the projectile missed one of the vehicles, hit a wall and exploded.
See also
Chronology of Provisional Irish Republican Army actions (1980-1989)
Ballygawley bus bombing
Clive Barracks bombing
1993 Fivemiletown ambush
The Troubles in Ballygawley
References
Further reading
Moloney, Ed: A Secret History of the IRA. Penguin Books (2002).
Urban, Mark: Big Boys' Rules: The SAS and the Secret Struggle Against the IRA. Faber and Faber (1992).
1985 in Northern Ireland
1985 murders in the United Kingdom
1980s in County Tyrone
Attacks in 1985
Attacks on police stations in the 1980s
Conflicts in 1985
Deaths by firearm in Northern Ireland
1985 crimes
December 1985 events
December 1985 events in Europe
Explosions in 1985
Improvised explosive device bombings in Northern Ireland
Military actions and engagements during the Troubles (Northern Ireland)
Military history of County Tyrone
Murder in County Tyrone
Provisional Irish Republican Army actions
Royal Ulster Constabulary
Terrorist incidents in County Tyrone
Terrorist incidents in the United Kingdom in 1985
1980s murders in Northern Ireland
1985 crimes in Ireland
The Troubles in County Tyrone
|
Malcolm Richard Wood (February 29, 1936 – April 4, 2015) was an American football quarterback and coach who played college football at Auburn and professionally in the American Football League (AFL). After his player career ended, Wood served as an assistant coach in college football and the National Football League (NFL) over four decades.
As a player
Playing for Lanett High School, Wood was named to the All-State team in Alabama in 1954. He went on to help lead Auburn to an undefeated season in 1958. He was drafted by the Baltimore Colts of the National Football League (NFL) in 1959. He never played for the Colts, and signed with the Denver Broncos of the American Football League (AFL) as a free agent in 1962. Later in that season, Wood saw his first significant playing time as a member of the San Diego Chargers, playing in 6 games and starting 2 (he filled in for teammates Jack Kemp and John Hadl). He then spent two seasons (1963 and 1964) with the New York Jets, starting 12 games in each year. The Jets drafted Joe Namath in 1965, and Wood landed as a backup for the Oakland Raiders, starting 3 games in relief of Tom Flores. The next year, he was a member of the Miami Dolphins' inaugural season.
Coaching career
In the next 30 years after his playing days, Wood held over a dozen offensive assistant coaching positions. He worked under Hank Stram in New Orleans as a quarterbacks coach, with Archie Manning under center. Afterwards, he was on the staff of the first Atlanta Falcons team to reach the playoffs in 1978. He coached Randall Cunningham and the Philadelphia Eagles during the early 1990s. He retired from coaching in 1997.
Statistics and legacy
Wood started 33 games and completed 522 career passes for 51 touchdowns and 71 interceptions in his professional career.
He played for five different AFL teams during his football career, the only player to ever do so.
Wood was the first quarterback to throw for a touchdown at Shea Stadium.
In 1966, Wood became the first starting quarterback in Miami Dolphins history.
Outside of football
Wood was married to Peggy Bartlett, who was also from his hometown of Lanett. The couple had a daughter and a son. After suffering from dementia, Wood died in Atlanta. He was 79.
See also
List of American Football League players
References
1936 births
2015 deaths
People from Lanett, Alabama
Players of American football from Alabama
American football quarterbacks
Auburn Tigers football players
Denver Broncos (AFL) players
San Diego Chargers players
New York Jets players
Oakland Raiders players
Miami Dolphins players
American Football League players
Coaches of American football from Alabama
Georgia Bulldogs football coaches
Oakland Raiders coaches
Ole Miss Rebels football coaches
Cleveland Browns coaches
New Orleans Saints coaches
Atlanta Falcons coaches
Auburn Tigers football coaches
Kansas City Chiefs coaches
New England Patriots coaches
Philadelphia Eagles coaches
New York Jets coaches
|
```objective-c
#pragma once
void RunLogDemo(int mode);
```
|
```gas
.text
.globl _rsaz_512_sqr
.p2align 5
_rsaz_512_sqr:
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $128+24,%rsp
L$sqr_body:
.byte 102,72,15,110,202
movq (%rsi),%rdx
movq 8(%rsi),%rax
movq %rcx,128(%rsp)
movl $0x80100,%r11d
andl _OPENSSL_ia32cap_P+8(%rip),%r11d
cmpl $0x80100,%r11d
je L$oop_sqrx
jmp L$oop_sqr
.p2align 5
L$oop_sqr:
movl %r8d,128+8(%rsp)
movq %rdx,%rbx
movq %rax,%rbp
mulq %rdx
movq %rax,%r8
movq 16(%rsi),%rax
movq %rdx,%r9
mulq %rbx
addq %rax,%r9
movq 24(%rsi),%rax
movq %rdx,%r10
adcq $0,%r10
mulq %rbx
addq %rax,%r10
movq 32(%rsi),%rax
movq %rdx,%r11
adcq $0,%r11
mulq %rbx
addq %rax,%r11
movq 40(%rsi),%rax
movq %rdx,%r12
adcq $0,%r12
mulq %rbx
addq %rax,%r12
movq 48(%rsi),%rax
movq %rdx,%r13
adcq $0,%r13
mulq %rbx
addq %rax,%r13
movq 56(%rsi),%rax
movq %rdx,%r14
adcq $0,%r14
mulq %rbx
addq %rax,%r14
movq %rbx,%rax
adcq $0,%rdx
xorq %rcx,%rcx
addq %r8,%r8
movq %rdx,%r15
adcq $0,%rcx
mulq %rax
addq %r8,%rdx
adcq $0,%rcx
movq %rax,(%rsp)
movq %rdx,8(%rsp)
movq 16(%rsi),%rax
mulq %rbp
addq %rax,%r10
movq 24(%rsi),%rax
movq %rdx,%rbx
adcq $0,%rbx
mulq %rbp
addq %rax,%r11
movq 32(%rsi),%rax
adcq $0,%rdx
addq %rbx,%r11
movq %rdx,%rbx
adcq $0,%rbx
mulq %rbp
addq %rax,%r12
movq 40(%rsi),%rax
adcq $0,%rdx
addq %rbx,%r12
movq %rdx,%rbx
adcq $0,%rbx
mulq %rbp
addq %rax,%r13
movq 48(%rsi),%rax
adcq $0,%rdx
addq %rbx,%r13
movq %rdx,%rbx
adcq $0,%rbx
mulq %rbp
addq %rax,%r14
movq 56(%rsi),%rax
adcq $0,%rdx
addq %rbx,%r14
movq %rdx,%rbx
adcq $0,%rbx
mulq %rbp
addq %rax,%r15
movq %rbp,%rax
adcq $0,%rdx
addq %rbx,%r15
adcq $0,%rdx
xorq %rbx,%rbx
addq %r9,%r9
movq %rdx,%r8
adcq %r10,%r10
adcq $0,%rbx
mulq %rax
addq %rcx,%rax
movq 16(%rsi),%rbp
addq %rax,%r9
movq 24(%rsi),%rax
adcq %rdx,%r10
adcq $0,%rbx
movq %r9,16(%rsp)
movq %r10,24(%rsp)
mulq %rbp
addq %rax,%r12
movq 32(%rsi),%rax
movq %rdx,%rcx
adcq $0,%rcx
mulq %rbp
addq %rax,%r13
movq 40(%rsi),%rax
adcq $0,%rdx
addq %rcx,%r13
movq %rdx,%rcx
adcq $0,%rcx
mulq %rbp
addq %rax,%r14
movq 48(%rsi),%rax
adcq $0,%rdx
addq %rcx,%r14
movq %rdx,%rcx
adcq $0,%rcx
mulq %rbp
addq %rax,%r15
movq 56(%rsi),%rax
adcq $0,%rdx
addq %rcx,%r15
movq %rdx,%rcx
adcq $0,%rcx
mulq %rbp
addq %rax,%r8
movq %rbp,%rax
adcq $0,%rdx
addq %rcx,%r8
adcq $0,%rdx
xorq %rcx,%rcx
addq %r11,%r11
movq %rdx,%r9
adcq %r12,%r12
adcq $0,%rcx
mulq %rax
addq %rbx,%rax
movq 24(%rsi),%r10
addq %rax,%r11
movq 32(%rsi),%rax
adcq %rdx,%r12
adcq $0,%rcx
movq %r11,32(%rsp)
movq %r12,40(%rsp)
movq %rax,%r11
mulq %r10
addq %rax,%r14
movq 40(%rsi),%rax
movq %rdx,%rbx
adcq $0,%rbx
movq %rax,%r12
mulq %r10
addq %rax,%r15
movq 48(%rsi),%rax
adcq $0,%rdx
addq %rbx,%r15
movq %rdx,%rbx
adcq $0,%rbx
movq %rax,%rbp
mulq %r10
addq %rax,%r8
movq 56(%rsi),%rax
adcq $0,%rdx
addq %rbx,%r8
movq %rdx,%rbx
adcq $0,%rbx
mulq %r10
addq %rax,%r9
movq %r10,%rax
adcq $0,%rdx
addq %rbx,%r9
adcq $0,%rdx
xorq %rbx,%rbx
addq %r13,%r13
movq %rdx,%r10
adcq %r14,%r14
adcq $0,%rbx
mulq %rax
addq %rcx,%rax
addq %rax,%r13
movq %r12,%rax
adcq %rdx,%r14
adcq $0,%rbx
movq %r13,48(%rsp)
movq %r14,56(%rsp)
mulq %r11
addq %rax,%r8
movq %rbp,%rax
movq %rdx,%rcx
adcq $0,%rcx
mulq %r11
addq %rax,%r9
movq 56(%rsi),%rax
adcq $0,%rdx
addq %rcx,%r9
movq %rdx,%rcx
adcq $0,%rcx
movq %rax,%r14
mulq %r11
addq %rax,%r10
movq %r11,%rax
adcq $0,%rdx
addq %rcx,%r10
adcq $0,%rdx
xorq %rcx,%rcx
addq %r15,%r15
movq %rdx,%r11
adcq %r8,%r8
adcq $0,%rcx
mulq %rax
addq %rbx,%rax
addq %rax,%r15
movq %rbp,%rax
adcq %rdx,%r8
adcq $0,%rcx
movq %r15,64(%rsp)
movq %r8,72(%rsp)
mulq %r12
addq %rax,%r10
movq %r14,%rax
movq %rdx,%rbx
adcq $0,%rbx
mulq %r12
addq %rax,%r11
movq %r12,%rax
adcq $0,%rdx
addq %rbx,%r11
adcq $0,%rdx
xorq %rbx,%rbx
addq %r9,%r9
movq %rdx,%r12
adcq %r10,%r10
adcq $0,%rbx
mulq %rax
addq %rcx,%rax
addq %rax,%r9
movq %r14,%rax
adcq %rdx,%r10
adcq $0,%rbx
movq %r9,80(%rsp)
movq %r10,88(%rsp)
mulq %rbp
addq %rax,%r12
movq %rbp,%rax
adcq $0,%rdx
xorq %rcx,%rcx
addq %r11,%r11
movq %rdx,%r13
adcq %r12,%r12
adcq $0,%rcx
mulq %rax
addq %rbx,%rax
addq %rax,%r11
movq %r14,%rax
adcq %rdx,%r12
adcq $0,%rcx
movq %r11,96(%rsp)
movq %r12,104(%rsp)
xorq %rbx,%rbx
addq %r13,%r13
adcq $0,%rbx
mulq %rax
addq %rcx,%rax
addq %r13,%rax
adcq %rbx,%rdx
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
.byte 102,72,15,126,205
movq %rax,112(%rsp)
movq %rdx,120(%rsp)
call __rsaz_512_reduce
addq 64(%rsp),%r8
adcq 72(%rsp),%r9
adcq 80(%rsp),%r10
adcq 88(%rsp),%r11
adcq 96(%rsp),%r12
adcq 104(%rsp),%r13
adcq 112(%rsp),%r14
adcq 120(%rsp),%r15
sbbq %rcx,%rcx
call __rsaz_512_subtract
movq %r8,%rdx
movq %r9,%rax
movl 128+8(%rsp),%r8d
movq %rdi,%rsi
decl %r8d
jnz L$oop_sqr
jmp L$sqr_tail
.p2align 5
L$oop_sqrx:
movl %r8d,128+8(%rsp)
.byte 102,72,15,110,199
mulxq %rax,%r8,%r9
movq %rax,%rbx
mulxq 16(%rsi),%rcx,%r10
xorq %rbp,%rbp
mulxq 24(%rsi),%rax,%r11
adcxq %rcx,%r9
.byte 0xc4,0x62,0xf3,0xf6,0xa6,0x20,0x00,0x00,0x00
adcxq %rax,%r10
.byte 0xc4,0x62,0xfb,0xf6,0xae,0x28,0x00,0x00,0x00
adcxq %rcx,%r11
mulxq 48(%rsi),%rcx,%r14
adcxq %rax,%r12
adcxq %rcx,%r13
mulxq 56(%rsi),%rax,%r15
adcxq %rax,%r14
adcxq %rbp,%r15
mulxq %rdx,%rax,%rdi
movq %rbx,%rdx
xorq %rcx,%rcx
adoxq %r8,%r8
adcxq %rdi,%r8
adoxq %rbp,%rcx
adcxq %rbp,%rcx
movq %rax,(%rsp)
movq %r8,8(%rsp)
.byte 0xc4,0xe2,0xfb,0xf6,0x9e,0x10,0x00,0x00,0x00
adoxq %rax,%r10
adcxq %rbx,%r11
mulxq 24(%rsi),%rdi,%r8
adoxq %rdi,%r11
.byte 0x66
adcxq %r8,%r12
mulxq 32(%rsi),%rax,%rbx
adoxq %rax,%r12
adcxq %rbx,%r13
mulxq 40(%rsi),%rdi,%r8
adoxq %rdi,%r13
adcxq %r8,%r14
.byte 0xc4,0xe2,0xfb,0xf6,0x9e,0x30,0x00,0x00,0x00
adoxq %rax,%r14
adcxq %rbx,%r15
.byte 0xc4,0x62,0xc3,0xf6,0x86,0x38,0x00,0x00,0x00
adoxq %rdi,%r15
adcxq %rbp,%r8
mulxq %rdx,%rax,%rdi
adoxq %rbp,%r8
.byte 0x48,0x8b,0x96,0x10,0x00,0x00,0x00
xorq %rbx,%rbx
adoxq %r9,%r9
adcxq %rcx,%rax
adoxq %r10,%r10
adcxq %rax,%r9
adoxq %rbp,%rbx
adcxq %rdi,%r10
adcxq %rbp,%rbx
movq %r9,16(%rsp)
.byte 0x4c,0x89,0x94,0x24,0x18,0x00,0x00,0x00
mulxq 24(%rsi),%rdi,%r9
adoxq %rdi,%r12
adcxq %r9,%r13
mulxq 32(%rsi),%rax,%rcx
adoxq %rax,%r13
adcxq %rcx,%r14
.byte 0xc4,0x62,0xc3,0xf6,0x8e,0x28,0x00,0x00,0x00
adoxq %rdi,%r14
adcxq %r9,%r15
.byte 0xc4,0xe2,0xfb,0xf6,0x8e,0x30,0x00,0x00,0x00
adoxq %rax,%r15
adcxq %rcx,%r8
mulxq 56(%rsi),%rdi,%r9
adoxq %rdi,%r8
adcxq %rbp,%r9
mulxq %rdx,%rax,%rdi
adoxq %rbp,%r9
movq 24(%rsi),%rdx
xorq %rcx,%rcx
adoxq %r11,%r11
adcxq %rbx,%rax
adoxq %r12,%r12
adcxq %rax,%r11
adoxq %rbp,%rcx
adcxq %rdi,%r12
adcxq %rbp,%rcx
movq %r11,32(%rsp)
movq %r12,40(%rsp)
mulxq 32(%rsi),%rax,%rbx
adoxq %rax,%r14
adcxq %rbx,%r15
mulxq 40(%rsi),%rdi,%r10
adoxq %rdi,%r15
adcxq %r10,%r8
mulxq 48(%rsi),%rax,%rbx
adoxq %rax,%r8
adcxq %rbx,%r9
mulxq 56(%rsi),%rdi,%r10
adoxq %rdi,%r9
adcxq %rbp,%r10
mulxq %rdx,%rax,%rdi
adoxq %rbp,%r10
movq 32(%rsi),%rdx
xorq %rbx,%rbx
adoxq %r13,%r13
adcxq %rcx,%rax
adoxq %r14,%r14
adcxq %rax,%r13
adoxq %rbp,%rbx
adcxq %rdi,%r14
adcxq %rbp,%rbx
movq %r13,48(%rsp)
movq %r14,56(%rsp)
mulxq 40(%rsi),%rdi,%r11
adoxq %rdi,%r8
adcxq %r11,%r9
mulxq 48(%rsi),%rax,%rcx
adoxq %rax,%r9
adcxq %rcx,%r10
mulxq 56(%rsi),%rdi,%r11
adoxq %rdi,%r10
adcxq %rbp,%r11
mulxq %rdx,%rax,%rdi
movq 40(%rsi),%rdx
adoxq %rbp,%r11
xorq %rcx,%rcx
adoxq %r15,%r15
adcxq %rbx,%rax
adoxq %r8,%r8
adcxq %rax,%r15
adoxq %rbp,%rcx
adcxq %rdi,%r8
adcxq %rbp,%rcx
movq %r15,64(%rsp)
movq %r8,72(%rsp)
.byte 0xc4,0xe2,0xfb,0xf6,0x9e,0x30,0x00,0x00,0x00
adoxq %rax,%r10
adcxq %rbx,%r11
.byte 0xc4,0x62,0xc3,0xf6,0xa6,0x38,0x00,0x00,0x00
adoxq %rdi,%r11
adcxq %rbp,%r12
mulxq %rdx,%rax,%rdi
adoxq %rbp,%r12
movq 48(%rsi),%rdx
xorq %rbx,%rbx
adoxq %r9,%r9
adcxq %rcx,%rax
adoxq %r10,%r10
adcxq %rax,%r9
adcxq %rdi,%r10
adoxq %rbp,%rbx
adcxq %rbp,%rbx
movq %r9,80(%rsp)
movq %r10,88(%rsp)
.byte 0xc4,0x62,0xfb,0xf6,0xae,0x38,0x00,0x00,0x00
adoxq %rax,%r12
adoxq %rbp,%r13
mulxq %rdx,%rax,%rdi
xorq %rcx,%rcx
movq 56(%rsi),%rdx
adoxq %r11,%r11
adcxq %rbx,%rax
adoxq %r12,%r12
adcxq %rax,%r11
adoxq %rbp,%rcx
adcxq %rdi,%r12
adcxq %rbp,%rcx
.byte 0x4c,0x89,0x9c,0x24,0x60,0x00,0x00,0x00
.byte 0x4c,0x89,0xa4,0x24,0x68,0x00,0x00,0x00
mulxq %rdx,%rax,%rdx
xorq %rbx,%rbx
adoxq %r13,%r13
adcxq %rcx,%rax
adoxq %rbp,%rbx
adcxq %r13,%rax
adcxq %rdx,%rbx
.byte 102,72,15,126,199
.byte 102,72,15,126,205
movq 128(%rsp),%rdx
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
movq %rax,112(%rsp)
movq %rbx,120(%rsp)
call __rsaz_512_reducex
addq 64(%rsp),%r8
adcq 72(%rsp),%r9
adcq 80(%rsp),%r10
adcq 88(%rsp),%r11
adcq 96(%rsp),%r12
adcq 104(%rsp),%r13
adcq 112(%rsp),%r14
adcq 120(%rsp),%r15
sbbq %rcx,%rcx
call __rsaz_512_subtract
movq %r8,%rdx
movq %r9,%rax
movl 128+8(%rsp),%r8d
movq %rdi,%rsi
decl %r8d
jnz L$oop_sqrx
L$sqr_tail:
leaq 128+24+48(%rsp),%rax
movq -48(%rax),%r15
movq -40(%rax),%r14
movq -32(%rax),%r13
movq -24(%rax),%r12
movq -16(%rax),%rbp
movq -8(%rax),%rbx
leaq (%rax),%rsp
L$sqr_epilogue:
.byte 0xf3,0xc3
.globl _rsaz_512_mul
.p2align 5
_rsaz_512_mul:
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $128+24,%rsp
L$mul_body:
.byte 102,72,15,110,199
.byte 102,72,15,110,201
movq %r8,128(%rsp)
movl $0x80100,%r11d
andl _OPENSSL_ia32cap_P+8(%rip),%r11d
cmpl $0x80100,%r11d
je L$mulx
movq (%rdx),%rbx
movq %rdx,%rbp
call __rsaz_512_mul
.byte 102,72,15,126,199
.byte 102,72,15,126,205
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
call __rsaz_512_reduce
jmp L$mul_tail
.p2align 5
L$mulx:
movq %rdx,%rbp
movq (%rdx),%rdx
call __rsaz_512_mulx
.byte 102,72,15,126,199
.byte 102,72,15,126,205
movq 128(%rsp),%rdx
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
call __rsaz_512_reducex
L$mul_tail:
addq 64(%rsp),%r8
adcq 72(%rsp),%r9
adcq 80(%rsp),%r10
adcq 88(%rsp),%r11
adcq 96(%rsp),%r12
adcq 104(%rsp),%r13
adcq 112(%rsp),%r14
adcq 120(%rsp),%r15
sbbq %rcx,%rcx
call __rsaz_512_subtract
leaq 128+24+48(%rsp),%rax
movq -48(%rax),%r15
movq -40(%rax),%r14
movq -32(%rax),%r13
movq -24(%rax),%r12
movq -16(%rax),%rbp
movq -8(%rax),%rbx
leaq (%rax),%rsp
L$mul_epilogue:
.byte 0xf3,0xc3
.globl _rsaz_512_mul_gather4
.p2align 5
_rsaz_512_mul_gather4:
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $152,%rsp
L$mul_gather4_body:
movd %r9d,%xmm8
movdqa L$inc+16(%rip),%xmm1
movdqa L$inc(%rip),%xmm0
pshufd $0,%xmm8,%xmm8
movdqa %xmm1,%xmm7
movdqa %xmm1,%xmm2
paddd %xmm0,%xmm1
pcmpeqd %xmm8,%xmm0
movdqa %xmm7,%xmm3
paddd %xmm1,%xmm2
pcmpeqd %xmm8,%xmm1
movdqa %xmm7,%xmm4
paddd %xmm2,%xmm3
pcmpeqd %xmm8,%xmm2
movdqa %xmm7,%xmm5
paddd %xmm3,%xmm4
pcmpeqd %xmm8,%xmm3
movdqa %xmm7,%xmm6
paddd %xmm4,%xmm5
pcmpeqd %xmm8,%xmm4
paddd %xmm5,%xmm6
pcmpeqd %xmm8,%xmm5
paddd %xmm6,%xmm7
pcmpeqd %xmm8,%xmm6
pcmpeqd %xmm8,%xmm7
movdqa 0(%rdx),%xmm8
movdqa 16(%rdx),%xmm9
movdqa 32(%rdx),%xmm10
movdqa 48(%rdx),%xmm11
pand %xmm0,%xmm8
movdqa 64(%rdx),%xmm12
pand %xmm1,%xmm9
movdqa 80(%rdx),%xmm13
pand %xmm2,%xmm10
movdqa 96(%rdx),%xmm14
pand %xmm3,%xmm11
movdqa 112(%rdx),%xmm15
leaq 128(%rdx),%rbp
pand %xmm4,%xmm12
pand %xmm5,%xmm13
pand %xmm6,%xmm14
pand %xmm7,%xmm15
por %xmm10,%xmm8
por %xmm11,%xmm9
por %xmm12,%xmm8
por %xmm13,%xmm9
por %xmm14,%xmm8
por %xmm15,%xmm9
por %xmm9,%xmm8
pshufd $0x4e,%xmm8,%xmm9
por %xmm9,%xmm8
movl $0x80100,%r11d
andl _OPENSSL_ia32cap_P+8(%rip),%r11d
cmpl $0x80100,%r11d
je L$mulx_gather
.byte 102,76,15,126,195
movq %r8,128(%rsp)
movq %rdi,128+8(%rsp)
movq %rcx,128+16(%rsp)
movq (%rsi),%rax
movq 8(%rsi),%rcx
mulq %rbx
movq %rax,(%rsp)
movq %rcx,%rax
movq %rdx,%r8
mulq %rbx
addq %rax,%r8
movq 16(%rsi),%rax
movq %rdx,%r9
adcq $0,%r9
mulq %rbx
addq %rax,%r9
movq 24(%rsi),%rax
movq %rdx,%r10
adcq $0,%r10
mulq %rbx
addq %rax,%r10
movq 32(%rsi),%rax
movq %rdx,%r11
adcq $0,%r11
mulq %rbx
addq %rax,%r11
movq 40(%rsi),%rax
movq %rdx,%r12
adcq $0,%r12
mulq %rbx
addq %rax,%r12
movq 48(%rsi),%rax
movq %rdx,%r13
adcq $0,%r13
mulq %rbx
addq %rax,%r13
movq 56(%rsi),%rax
movq %rdx,%r14
adcq $0,%r14
mulq %rbx
addq %rax,%r14
movq (%rsi),%rax
movq %rdx,%r15
adcq $0,%r15
leaq 8(%rsp),%rdi
movl $7,%ecx
jmp L$oop_mul_gather
.p2align 5
L$oop_mul_gather:
movdqa 0(%rbp),%xmm8
movdqa 16(%rbp),%xmm9
movdqa 32(%rbp),%xmm10
movdqa 48(%rbp),%xmm11
pand %xmm0,%xmm8
movdqa 64(%rbp),%xmm12
pand %xmm1,%xmm9
movdqa 80(%rbp),%xmm13
pand %xmm2,%xmm10
movdqa 96(%rbp),%xmm14
pand %xmm3,%xmm11
movdqa 112(%rbp),%xmm15
leaq 128(%rbp),%rbp
pand %xmm4,%xmm12
pand %xmm5,%xmm13
pand %xmm6,%xmm14
pand %xmm7,%xmm15
por %xmm10,%xmm8
por %xmm11,%xmm9
por %xmm12,%xmm8
por %xmm13,%xmm9
por %xmm14,%xmm8
por %xmm15,%xmm9
por %xmm9,%xmm8
pshufd $0x4e,%xmm8,%xmm9
por %xmm9,%xmm8
.byte 102,76,15,126,195
mulq %rbx
addq %rax,%r8
movq 8(%rsi),%rax
movq %r8,(%rdi)
movq %rdx,%r8
adcq $0,%r8
mulq %rbx
addq %rax,%r9
movq 16(%rsi),%rax
adcq $0,%rdx
addq %r9,%r8
movq %rdx,%r9
adcq $0,%r9
mulq %rbx
addq %rax,%r10
movq 24(%rsi),%rax
adcq $0,%rdx
addq %r10,%r9
movq %rdx,%r10
adcq $0,%r10
mulq %rbx
addq %rax,%r11
movq 32(%rsi),%rax
adcq $0,%rdx
addq %r11,%r10
movq %rdx,%r11
adcq $0,%r11
mulq %rbx
addq %rax,%r12
movq 40(%rsi),%rax
adcq $0,%rdx
addq %r12,%r11
movq %rdx,%r12
adcq $0,%r12
mulq %rbx
addq %rax,%r13
movq 48(%rsi),%rax
adcq $0,%rdx
addq %r13,%r12
movq %rdx,%r13
adcq $0,%r13
mulq %rbx
addq %rax,%r14
movq 56(%rsi),%rax
adcq $0,%rdx
addq %r14,%r13
movq %rdx,%r14
adcq $0,%r14
mulq %rbx
addq %rax,%r15
movq (%rsi),%rax
adcq $0,%rdx
addq %r15,%r14
movq %rdx,%r15
adcq $0,%r15
leaq 8(%rdi),%rdi
decl %ecx
jnz L$oop_mul_gather
movq %r8,(%rdi)
movq %r9,8(%rdi)
movq %r10,16(%rdi)
movq %r11,24(%rdi)
movq %r12,32(%rdi)
movq %r13,40(%rdi)
movq %r14,48(%rdi)
movq %r15,56(%rdi)
movq 128+8(%rsp),%rdi
movq 128+16(%rsp),%rbp
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
call __rsaz_512_reduce
jmp L$mul_gather_tail
.p2align 5
L$mulx_gather:
.byte 102,76,15,126,194
movq %r8,128(%rsp)
movq %rdi,128+8(%rsp)
movq %rcx,128+16(%rsp)
mulxq (%rsi),%rbx,%r8
movq %rbx,(%rsp)
xorl %edi,%edi
mulxq 8(%rsi),%rax,%r9
mulxq 16(%rsi),%rbx,%r10
adcxq %rax,%r8
mulxq 24(%rsi),%rax,%r11
adcxq %rbx,%r9
mulxq 32(%rsi),%rbx,%r12
adcxq %rax,%r10
mulxq 40(%rsi),%rax,%r13
adcxq %rbx,%r11
mulxq 48(%rsi),%rbx,%r14
adcxq %rax,%r12
mulxq 56(%rsi),%rax,%r15
adcxq %rbx,%r13
adcxq %rax,%r14
.byte 0x67
movq %r8,%rbx
adcxq %rdi,%r15
movq $-7,%rcx
jmp L$oop_mulx_gather
.p2align 5
L$oop_mulx_gather:
movdqa 0(%rbp),%xmm8
movdqa 16(%rbp),%xmm9
movdqa 32(%rbp),%xmm10
movdqa 48(%rbp),%xmm11
pand %xmm0,%xmm8
movdqa 64(%rbp),%xmm12
pand %xmm1,%xmm9
movdqa 80(%rbp),%xmm13
pand %xmm2,%xmm10
movdqa 96(%rbp),%xmm14
pand %xmm3,%xmm11
movdqa 112(%rbp),%xmm15
leaq 128(%rbp),%rbp
pand %xmm4,%xmm12
pand %xmm5,%xmm13
pand %xmm6,%xmm14
pand %xmm7,%xmm15
por %xmm10,%xmm8
por %xmm11,%xmm9
por %xmm12,%xmm8
por %xmm13,%xmm9
por %xmm14,%xmm8
por %xmm15,%xmm9
por %xmm9,%xmm8
pshufd $0x4e,%xmm8,%xmm9
por %xmm9,%xmm8
.byte 102,76,15,126,194
.byte 0xc4,0x62,0xfb,0xf6,0x86,0x00,0x00,0x00,0x00
adcxq %rax,%rbx
adoxq %r9,%r8
mulxq 8(%rsi),%rax,%r9
adcxq %rax,%r8
adoxq %r10,%r9
mulxq 16(%rsi),%rax,%r10
adcxq %rax,%r9
adoxq %r11,%r10
.byte 0xc4,0x62,0xfb,0xf6,0x9e,0x18,0x00,0x00,0x00
adcxq %rax,%r10
adoxq %r12,%r11
mulxq 32(%rsi),%rax,%r12
adcxq %rax,%r11
adoxq %r13,%r12
mulxq 40(%rsi),%rax,%r13
adcxq %rax,%r12
adoxq %r14,%r13
.byte 0xc4,0x62,0xfb,0xf6,0xb6,0x30,0x00,0x00,0x00
adcxq %rax,%r13
.byte 0x67
adoxq %r15,%r14
mulxq 56(%rsi),%rax,%r15
movq %rbx,64(%rsp,%rcx,8)
adcxq %rax,%r14
adoxq %rdi,%r15
movq %r8,%rbx
adcxq %rdi,%r15
incq %rcx
jnz L$oop_mulx_gather
movq %r8,64(%rsp)
movq %r9,64+8(%rsp)
movq %r10,64+16(%rsp)
movq %r11,64+24(%rsp)
movq %r12,64+32(%rsp)
movq %r13,64+40(%rsp)
movq %r14,64+48(%rsp)
movq %r15,64+56(%rsp)
movq 128(%rsp),%rdx
movq 128+8(%rsp),%rdi
movq 128+16(%rsp),%rbp
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
call __rsaz_512_reducex
L$mul_gather_tail:
addq 64(%rsp),%r8
adcq 72(%rsp),%r9
adcq 80(%rsp),%r10
adcq 88(%rsp),%r11
adcq 96(%rsp),%r12
adcq 104(%rsp),%r13
adcq 112(%rsp),%r14
adcq 120(%rsp),%r15
sbbq %rcx,%rcx
call __rsaz_512_subtract
leaq 128+24+48(%rsp),%rax
movq -48(%rax),%r15
movq -40(%rax),%r14
movq -32(%rax),%r13
movq -24(%rax),%r12
movq -16(%rax),%rbp
movq -8(%rax),%rbx
leaq (%rax),%rsp
L$mul_gather4_epilogue:
.byte 0xf3,0xc3
.globl _rsaz_512_mul_scatter4
.p2align 5
_rsaz_512_mul_scatter4:
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
movl %r9d,%r9d
subq $128+24,%rsp
L$mul_scatter4_body:
leaq (%r8,%r9,8),%r8
.byte 102,72,15,110,199
.byte 102,72,15,110,202
.byte 102,73,15,110,208
movq %rcx,128(%rsp)
movq %rdi,%rbp
movl $0x80100,%r11d
andl _OPENSSL_ia32cap_P+8(%rip),%r11d
cmpl $0x80100,%r11d
je L$mulx_scatter
movq (%rdi),%rbx
call __rsaz_512_mul
.byte 102,72,15,126,199
.byte 102,72,15,126,205
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
call __rsaz_512_reduce
jmp L$mul_scatter_tail
.p2align 5
L$mulx_scatter:
movq (%rdi),%rdx
call __rsaz_512_mulx
.byte 102,72,15,126,199
.byte 102,72,15,126,205
movq 128(%rsp),%rdx
movq (%rsp),%r8
movq 8(%rsp),%r9
movq 16(%rsp),%r10
movq 24(%rsp),%r11
movq 32(%rsp),%r12
movq 40(%rsp),%r13
movq 48(%rsp),%r14
movq 56(%rsp),%r15
call __rsaz_512_reducex
L$mul_scatter_tail:
addq 64(%rsp),%r8
adcq 72(%rsp),%r9
adcq 80(%rsp),%r10
adcq 88(%rsp),%r11
adcq 96(%rsp),%r12
adcq 104(%rsp),%r13
adcq 112(%rsp),%r14
adcq 120(%rsp),%r15
.byte 102,72,15,126,214
sbbq %rcx,%rcx
call __rsaz_512_subtract
movq %r8,0(%rsi)
movq %r9,128(%rsi)
movq %r10,256(%rsi)
movq %r11,384(%rsi)
movq %r12,512(%rsi)
movq %r13,640(%rsi)
movq %r14,768(%rsi)
movq %r15,896(%rsi)
leaq 128+24+48(%rsp),%rax
movq -48(%rax),%r15
movq -40(%rax),%r14
movq -32(%rax),%r13
movq -24(%rax),%r12
movq -16(%rax),%rbp
movq -8(%rax),%rbx
leaq (%rax),%rsp
L$mul_scatter4_epilogue:
.byte 0xf3,0xc3
.globl _rsaz_512_mul_by_one
.p2align 5
_rsaz_512_mul_by_one:
pushq %rbx
pushq %rbp
pushq %r12
pushq %r13
pushq %r14
pushq %r15
subq $128+24,%rsp
L$mul_by_one_body:
movl _OPENSSL_ia32cap_P+8(%rip),%eax
movq %rdx,%rbp
movq %rcx,128(%rsp)
movq (%rsi),%r8
pxor %xmm0,%xmm0
movq 8(%rsi),%r9
movq 16(%rsi),%r10
movq 24(%rsi),%r11
movq 32(%rsi),%r12
movq 40(%rsi),%r13
movq 48(%rsi),%r14
movq 56(%rsi),%r15
movdqa %xmm0,(%rsp)
movdqa %xmm0,16(%rsp)
movdqa %xmm0,32(%rsp)
movdqa %xmm0,48(%rsp)
movdqa %xmm0,64(%rsp)
movdqa %xmm0,80(%rsp)
movdqa %xmm0,96(%rsp)
andl $0x80100,%eax
cmpl $0x80100,%eax
je L$by_one_callx
call __rsaz_512_reduce
jmp L$by_one_tail
.p2align 5
L$by_one_callx:
movq 128(%rsp),%rdx
call __rsaz_512_reducex
L$by_one_tail:
movq %r8,(%rdi)
movq %r9,8(%rdi)
movq %r10,16(%rdi)
movq %r11,24(%rdi)
movq %r12,32(%rdi)
movq %r13,40(%rdi)
movq %r14,48(%rdi)
movq %r15,56(%rdi)
leaq 128+24+48(%rsp),%rax
movq -48(%rax),%r15
movq -40(%rax),%r14
movq -32(%rax),%r13
movq -24(%rax),%r12
movq -16(%rax),%rbp
movq -8(%rax),%rbx
leaq (%rax),%rsp
L$mul_by_one_epilogue:
.byte 0xf3,0xc3
.p2align 5
__rsaz_512_reduce:
movq %r8,%rbx
imulq 128+8(%rsp),%rbx
movq 0(%rbp),%rax
movl $8,%ecx
jmp L$reduction_loop
.p2align 5
L$reduction_loop:
mulq %rbx
movq 8(%rbp),%rax
negq %r8
movq %rdx,%r8
adcq $0,%r8
mulq %rbx
addq %rax,%r9
movq 16(%rbp),%rax
adcq $0,%rdx
addq %r9,%r8
movq %rdx,%r9
adcq $0,%r9
mulq %rbx
addq %rax,%r10
movq 24(%rbp),%rax
adcq $0,%rdx
addq %r10,%r9
movq %rdx,%r10
adcq $0,%r10
mulq %rbx
addq %rax,%r11
movq 32(%rbp),%rax
adcq $0,%rdx
addq %r11,%r10
movq 128+8(%rsp),%rsi
adcq $0,%rdx
movq %rdx,%r11
mulq %rbx
addq %rax,%r12
movq 40(%rbp),%rax
adcq $0,%rdx
imulq %r8,%rsi
addq %r12,%r11
movq %rdx,%r12
adcq $0,%r12
mulq %rbx
addq %rax,%r13
movq 48(%rbp),%rax
adcq $0,%rdx
addq %r13,%r12
movq %rdx,%r13
adcq $0,%r13
mulq %rbx
addq %rax,%r14
movq 56(%rbp),%rax
adcq $0,%rdx
addq %r14,%r13
movq %rdx,%r14
adcq $0,%r14
mulq %rbx
movq %rsi,%rbx
addq %rax,%r15
movq 0(%rbp),%rax
adcq $0,%rdx
addq %r15,%r14
movq %rdx,%r15
adcq $0,%r15
decl %ecx
jne L$reduction_loop
.byte 0xf3,0xc3
.p2align 5
__rsaz_512_reducex:
imulq %r8,%rdx
xorq %rsi,%rsi
movl $8,%ecx
jmp L$reduction_loopx
.p2align 5
L$reduction_loopx:
movq %r8,%rbx
mulxq 0(%rbp),%rax,%r8
adcxq %rbx,%rax
adoxq %r9,%r8
mulxq 8(%rbp),%rax,%r9
adcxq %rax,%r8
adoxq %r10,%r9
mulxq 16(%rbp),%rbx,%r10
adcxq %rbx,%r9
adoxq %r11,%r10
mulxq 24(%rbp),%rbx,%r11
adcxq %rbx,%r10
adoxq %r12,%r11
.byte 0xc4,0x62,0xe3,0xf6,0xa5,0x20,0x00,0x00,0x00
movq %rdx,%rax
movq %r8,%rdx
adcxq %rbx,%r11
adoxq %r13,%r12
mulxq 128+8(%rsp),%rbx,%rdx
movq %rax,%rdx
mulxq 40(%rbp),%rax,%r13
adcxq %rax,%r12
adoxq %r14,%r13
.byte 0xc4,0x62,0xfb,0xf6,0xb5,0x30,0x00,0x00,0x00
adcxq %rax,%r13
adoxq %r15,%r14
mulxq 56(%rbp),%rax,%r15
movq %rbx,%rdx
adcxq %rax,%r14
adoxq %rsi,%r15
adcxq %rsi,%r15
decl %ecx
jne L$reduction_loopx
.byte 0xf3,0xc3
.p2align 5
__rsaz_512_subtract:
movq %r8,(%rdi)
movq %r9,8(%rdi)
movq %r10,16(%rdi)
movq %r11,24(%rdi)
movq %r12,32(%rdi)
movq %r13,40(%rdi)
movq %r14,48(%rdi)
movq %r15,56(%rdi)
movq 0(%rbp),%r8
movq 8(%rbp),%r9
negq %r8
notq %r9
andq %rcx,%r8
movq 16(%rbp),%r10
andq %rcx,%r9
notq %r10
movq 24(%rbp),%r11
andq %rcx,%r10
notq %r11
movq 32(%rbp),%r12
andq %rcx,%r11
notq %r12
movq 40(%rbp),%r13
andq %rcx,%r12
notq %r13
movq 48(%rbp),%r14
andq %rcx,%r13
notq %r14
movq 56(%rbp),%r15
andq %rcx,%r14
notq %r15
andq %rcx,%r15
addq (%rdi),%r8
adcq 8(%rdi),%r9
adcq 16(%rdi),%r10
adcq 24(%rdi),%r11
adcq 32(%rdi),%r12
adcq 40(%rdi),%r13
adcq 48(%rdi),%r14
adcq 56(%rdi),%r15
movq %r8,(%rdi)
movq %r9,8(%rdi)
movq %r10,16(%rdi)
movq %r11,24(%rdi)
movq %r12,32(%rdi)
movq %r13,40(%rdi)
movq %r14,48(%rdi)
movq %r15,56(%rdi)
.byte 0xf3,0xc3
.p2align 5
__rsaz_512_mul:
leaq 8(%rsp),%rdi
movq (%rsi),%rax
mulq %rbx
movq %rax,(%rdi)
movq 8(%rsi),%rax
movq %rdx,%r8
mulq %rbx
addq %rax,%r8
movq 16(%rsi),%rax
movq %rdx,%r9
adcq $0,%r9
mulq %rbx
addq %rax,%r9
movq 24(%rsi),%rax
movq %rdx,%r10
adcq $0,%r10
mulq %rbx
addq %rax,%r10
movq 32(%rsi),%rax
movq %rdx,%r11
adcq $0,%r11
mulq %rbx
addq %rax,%r11
movq 40(%rsi),%rax
movq %rdx,%r12
adcq $0,%r12
mulq %rbx
addq %rax,%r12
movq 48(%rsi),%rax
movq %rdx,%r13
adcq $0,%r13
mulq %rbx
addq %rax,%r13
movq 56(%rsi),%rax
movq %rdx,%r14
adcq $0,%r14
mulq %rbx
addq %rax,%r14
movq (%rsi),%rax
movq %rdx,%r15
adcq $0,%r15
leaq 8(%rbp),%rbp
leaq 8(%rdi),%rdi
movl $7,%ecx
jmp L$oop_mul
.p2align 5
L$oop_mul:
movq (%rbp),%rbx
mulq %rbx
addq %rax,%r8
movq 8(%rsi),%rax
movq %r8,(%rdi)
movq %rdx,%r8
adcq $0,%r8
mulq %rbx
addq %rax,%r9
movq 16(%rsi),%rax
adcq $0,%rdx
addq %r9,%r8
movq %rdx,%r9
adcq $0,%r9
mulq %rbx
addq %rax,%r10
movq 24(%rsi),%rax
adcq $0,%rdx
addq %r10,%r9
movq %rdx,%r10
adcq $0,%r10
mulq %rbx
addq %rax,%r11
movq 32(%rsi),%rax
adcq $0,%rdx
addq %r11,%r10
movq %rdx,%r11
adcq $0,%r11
mulq %rbx
addq %rax,%r12
movq 40(%rsi),%rax
adcq $0,%rdx
addq %r12,%r11
movq %rdx,%r12
adcq $0,%r12
mulq %rbx
addq %rax,%r13
movq 48(%rsi),%rax
adcq $0,%rdx
addq %r13,%r12
movq %rdx,%r13
adcq $0,%r13
mulq %rbx
addq %rax,%r14
movq 56(%rsi),%rax
adcq $0,%rdx
addq %r14,%r13
movq %rdx,%r14
leaq 8(%rbp),%rbp
adcq $0,%r14
mulq %rbx
addq %rax,%r15
movq (%rsi),%rax
adcq $0,%rdx
addq %r15,%r14
movq %rdx,%r15
adcq $0,%r15
leaq 8(%rdi),%rdi
decl %ecx
jnz L$oop_mul
movq %r8,(%rdi)
movq %r9,8(%rdi)
movq %r10,16(%rdi)
movq %r11,24(%rdi)
movq %r12,32(%rdi)
movq %r13,40(%rdi)
movq %r14,48(%rdi)
movq %r15,56(%rdi)
.byte 0xf3,0xc3
.p2align 5
__rsaz_512_mulx:
mulxq (%rsi),%rbx,%r8
movq $-6,%rcx
mulxq 8(%rsi),%rax,%r9
movq %rbx,8(%rsp)
mulxq 16(%rsi),%rbx,%r10
adcq %rax,%r8
mulxq 24(%rsi),%rax,%r11
adcq %rbx,%r9
mulxq 32(%rsi),%rbx,%r12
adcq %rax,%r10
mulxq 40(%rsi),%rax,%r13
adcq %rbx,%r11
mulxq 48(%rsi),%rbx,%r14
adcq %rax,%r12
mulxq 56(%rsi),%rax,%r15
movq 8(%rbp),%rdx
adcq %rbx,%r13
adcq %rax,%r14
adcq $0,%r15
xorq %rdi,%rdi
jmp L$oop_mulx
.p2align 5
L$oop_mulx:
movq %r8,%rbx
mulxq (%rsi),%rax,%r8
adcxq %rax,%rbx
adoxq %r9,%r8
mulxq 8(%rsi),%rax,%r9
adcxq %rax,%r8
adoxq %r10,%r9
mulxq 16(%rsi),%rax,%r10
adcxq %rax,%r9
adoxq %r11,%r10
mulxq 24(%rsi),%rax,%r11
adcxq %rax,%r10
adoxq %r12,%r11
.byte 0x3e,0xc4,0x62,0xfb,0xf6,0xa6,0x20,0x00,0x00,0x00
adcxq %rax,%r11
adoxq %r13,%r12
mulxq 40(%rsi),%rax,%r13
adcxq %rax,%r12
adoxq %r14,%r13
mulxq 48(%rsi),%rax,%r14
adcxq %rax,%r13
adoxq %r15,%r14
mulxq 56(%rsi),%rax,%r15
movq 64(%rbp,%rcx,8),%rdx
movq %rbx,8+64-8(%rsp,%rcx,8)
adcxq %rax,%r14
adoxq %rdi,%r15
adcxq %rdi,%r15
incq %rcx
jnz L$oop_mulx
movq %r8,%rbx
mulxq (%rsi),%rax,%r8
adcxq %rax,%rbx
adoxq %r9,%r8
.byte 0xc4,0x62,0xfb,0xf6,0x8e,0x08,0x00,0x00,0x00
adcxq %rax,%r8
adoxq %r10,%r9
.byte 0xc4,0x62,0xfb,0xf6,0x96,0x10,0x00,0x00,0x00
adcxq %rax,%r9
adoxq %r11,%r10
mulxq 24(%rsi),%rax,%r11
adcxq %rax,%r10
adoxq %r12,%r11
mulxq 32(%rsi),%rax,%r12
adcxq %rax,%r11
adoxq %r13,%r12
mulxq 40(%rsi),%rax,%r13
adcxq %rax,%r12
adoxq %r14,%r13
.byte 0xc4,0x62,0xfb,0xf6,0xb6,0x30,0x00,0x00,0x00
adcxq %rax,%r13
adoxq %r15,%r14
.byte 0xc4,0x62,0xfb,0xf6,0xbe,0x38,0x00,0x00,0x00
adcxq %rax,%r14
adoxq %rdi,%r15
adcxq %rdi,%r15
movq %rbx,8+64-8(%rsp)
movq %r8,8+64(%rsp)
movq %r9,8+64+8(%rsp)
movq %r10,8+64+16(%rsp)
movq %r11,8+64+24(%rsp)
movq %r12,8+64+32(%rsp)
movq %r13,8+64+40(%rsp)
movq %r14,8+64+48(%rsp)
movq %r15,8+64+56(%rsp)
.byte 0xf3,0xc3
.globl _rsaz_512_scatter4
.p2align 4
_rsaz_512_scatter4:
leaq (%rdi,%rdx,8),%rdi
movl $8,%r9d
jmp L$oop_scatter
.p2align 4
L$oop_scatter:
movq (%rsi),%rax
leaq 8(%rsi),%rsi
movq %rax,(%rdi)
leaq 128(%rdi),%rdi
decl %r9d
jnz L$oop_scatter
.byte 0xf3,0xc3
.globl _rsaz_512_gather4
.p2align 4
_rsaz_512_gather4:
movd %edx,%xmm8
movdqa L$inc+16(%rip),%xmm1
movdqa L$inc(%rip),%xmm0
pshufd $0,%xmm8,%xmm8
movdqa %xmm1,%xmm7
movdqa %xmm1,%xmm2
paddd %xmm0,%xmm1
pcmpeqd %xmm8,%xmm0
movdqa %xmm7,%xmm3
paddd %xmm1,%xmm2
pcmpeqd %xmm8,%xmm1
movdqa %xmm7,%xmm4
paddd %xmm2,%xmm3
pcmpeqd %xmm8,%xmm2
movdqa %xmm7,%xmm5
paddd %xmm3,%xmm4
pcmpeqd %xmm8,%xmm3
movdqa %xmm7,%xmm6
paddd %xmm4,%xmm5
pcmpeqd %xmm8,%xmm4
paddd %xmm5,%xmm6
pcmpeqd %xmm8,%xmm5
paddd %xmm6,%xmm7
pcmpeqd %xmm8,%xmm6
pcmpeqd %xmm8,%xmm7
movl $8,%r9d
jmp L$oop_gather
.p2align 4
L$oop_gather:
movdqa 0(%rsi),%xmm8
movdqa 16(%rsi),%xmm9
movdqa 32(%rsi),%xmm10
movdqa 48(%rsi),%xmm11
pand %xmm0,%xmm8
movdqa 64(%rsi),%xmm12
pand %xmm1,%xmm9
movdqa 80(%rsi),%xmm13
pand %xmm2,%xmm10
movdqa 96(%rsi),%xmm14
pand %xmm3,%xmm11
movdqa 112(%rsi),%xmm15
leaq 128(%rsi),%rsi
pand %xmm4,%xmm12
pand %xmm5,%xmm13
pand %xmm6,%xmm14
pand %xmm7,%xmm15
por %xmm10,%xmm8
por %xmm11,%xmm9
por %xmm12,%xmm8
por %xmm13,%xmm9
por %xmm14,%xmm8
por %xmm15,%xmm9
por %xmm9,%xmm8
pshufd $0x4e,%xmm8,%xmm9
por %xmm9,%xmm8
movq %xmm8,(%rdi)
leaq 8(%rdi),%rdi
decl %r9d
jnz L$oop_gather
.byte 0xf3,0xc3
L$SEH_end_rsaz_512_gather4:
.p2align 6
L$inc:
.long 0,0, 1,1
.long 2,2, 2,2
```
|
```php
<?php
/*
*
* ____ _ _ __ __ _ __ __ ____
* | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \
* | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
* | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/
* |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_|
*
* This program is free software: you can redistribute it and/or modify
* (at your option) any later version.
*
* @author PocketMine Team
* @link path_to_url
*
*
*/
declare(strict_types=1);
namespace pocketmine\world\sound;
use pocketmine\math\Vector3;
use pocketmine\network\mcpe\protocol\LevelEventPacket;
use pocketmine\network\mcpe\protocol\types\LevelEvent;
class PopSound implements Sound{
public function __construct(private float $pitch = 0){}
public function getPitch() : float{
return $this->pitch;
}
public function encode(Vector3 $pos) : array{
return [LevelEventPacket::create(LevelEvent::SOUND_POP, (int) ($this->pitch * 1000), $pos)];
}
}
```
|
Grahovo ( or , ) is a village on the eastern shores of Lake Cerknica in the Municipality of Cerknica in the Inner Carniola region of Slovenia.
Name
Grahovo was attested in written sources in 1355 and 1499 as Grochaw (and as Grocha in 1438 and 1487, and Grathaw in 1448). The name is probably derived from the personal name Grah, which is still preserved as a surname in Slovenia and is probably borrowed from the Old High German name Gracco. The place name would thus mean 'Grah's (village)'. Another possible derivation is from the common noun *grahovišče 'pea field' via the contracted form *grahovše. Direct derivation from the Slovene common noun grah 'pea' is unlikely because of the rarity of such names and the suffixation pattern. The name Grahova vas is also occasionally found in some dated sources.
Memorials
In 1990, a memorial to poet France Balantič was erected in front of the local school.
In 2014, another memorial was erected to 32 Slovene Home Guard members that were killed in the 1943 attack by the Slovene Partisans. The choice to erect it on anniversary date of the 1941 Axis invasion of Yugoslavia was met with criticism by the Slovene Partisan veterans association, Primorski Puntarji, and some left-wing political parties, which accused right-wing political leaders of trying to rehabilitate collaborationism. In addition to the left-wing veterans associations, a petition against the second monument was also signed by the TIGR veterans association. The monument was vandalized on April 16, 2014 and again on April 11, 2020.
Church
The Grahovo parish church, built southeast of the settlement in 1992, is dedicated to the Immaculate Conception and belongs to the Ljubljana Archdiocese. The original church dating to 1671 was burned down during the Partisan attack on 24 November 1943. The people of the village were not permitted to remove the ruins until 1960, and permission was not granted to build a new church until after Slovenian independence in 1991.
Gallery
References
External links
Grahovo on Geopedia
Populated places in the Municipality of Cerknica
|
```c
/*############################################################################
#
#
# 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.
############################################################################*/
/// Tiny member RegisterBaseName implementation.
/*! \file */
#define EXPORT_EPID_APIS
#include "epid/member/api.h"
#include "epid/member/tiny/src/allowed_basenames.h"
#include "epid/member/tiny/src/context.h"
EpidStatus EPID_API EpidRegisterBasename(MemberCtx* ctx, void const* basename,
size_t basename_len) {
if (basename_len == 0) {
return kEpidBadArgErr;
}
if (!ctx || !basename) {
return kEpidBadArgErr;
}
if (IsBasenameAllowed(ctx->allowed_basenames, basename, basename_len)) {
return kEpidDuplicateErr;
}
return AllowBasename(ctx->allowed_basenames, basename, basename_len)
? kEpidNoErr
: kEpidNoMemErr;
}
EpidStatus EPID_API EpidClearRegisteredBasenames(MemberCtx* ctx) {
if (!ctx) {
return kEpidBadArgErr;
}
InitBasenames(ctx->allowed_basenames, MAX_ALLOWED_BASENAMES);
return kEpidNoErr;
}
```
|
Banatski Karlovac () is a town located in the Alibunar Municipality, in the South Banat District of Serbia. It is situated in the Autonomous Province of Vojvodina. The town has a Serb ethnic majority and its population numbers 5,820 people (2002 census). The nearby settlement of Devojački Bunar is also officially part of Banatski Karlovac.
Name
In Serbian, the town is known as Banatski Karlovac (Банатски Карловац), in German as Karlsdorf, and in Hungarian as Nagykárolyfalva. Adjective "Banatski" (i.e. "Banatian") was given to differentiate the town from the city of Karlovac in Croatia.
History
This area was inhabited by humans during the Bronze Age, as well as in the 3rd and 4th century AD. During the Ottoman administration, settlement named Hoča or Oča existed at this location. Settlement named Oča was also mentioned in 1764. During the 18th century, the settlement was populated by Serbs.
Ethnic Germans settled in the settlement starting in 1803, and in the same year some Slavic Krašovani settlers from eastern Banat settled here as well. In 1921, name of the settlement was Karlovo Selo, and in 1926, it was officially named Banatski Karlovac. In the same year, the reading room was founded and monument dedicated to Serbs killed in 1848 revolution was built.
Before the end of World War II, most of the inhabitants of this town were ethnic Germans. After the war, their property was confiscated by the state and Germans were expelled or killed in concentration camps run by Yugoslav communist authorities. A German Lutheran church was razed off soon after the expulsion of Germans.
After the war, 615 (mostly Serb) families with 3,775 family members settled in the town. They originated from Central Serbia, Bosnia and Montenegro, mostly from area around Užice and Čačak. Some settlers were not satisfied with life conditions in the town, so about 80 families returned to their place of origin. In 1949, town was named Banatsko Rankovićevo, and this name was in use until 1956, when old name Banatski Karlovac was returned.
Historical population
Notable citizens
Rock musician Nikola Čuturilo was born in Banatski Karlovac.
Climate
See also
List of places in Serbia
List of cities, towns and villages in Vojvodina
References
External links
Unofficial Website
LEADER+BK Website
Municipality of Alibunar
Populated places in Serbian Banat
Populated places in South Banat District
Alibunar
Towns in Serbia
|
Masahiko Sawaguchi (澤口 雅彦, born July 22, 1985) is a Japanese football player who plays for Ococias Kyoto AC.
Career
On 8 February 2019, Sawaguchi joined Ococias Kyoto AC.
Club statistics
Updated to 23 February 2018.
References
External links
1985 births
Living people
Ryutsu Keizai University alumni
Association football people from Ibaraki Prefecture
Japanese men's footballers
J2 League players
Japan Football League players
FC Ryukyu players
Fagiano Okayama players
Ococias Kyoto AC players
Men's association football midfielders
|
```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 store
import (
"testing"
rbacv1 "k8s.io/api/rbac/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
generator "k8s.io/kube-state-metrics/v2/pkg/metric_generator"
)
func TestClusterRoleBindingStore(t *testing.T) {
startTime := 1501569018
metav1StartTime := metav1.Unix(int64(startTime), 0)
cases := []generateMetricsTestCase{
{
AllowAnnotationsList: []string{
"app.k8s.io/owner",
},
AllowLabelsList: []string{
"app",
},
Obj: &rbacv1.ClusterRoleBinding{
ObjectMeta: metav1.ObjectMeta{
Name: "clusterrolebinding1",
ResourceVersion: "BBBBB",
Annotations: map[string]string{
"app": "mysql-server",
"app.k8s.io/owner": "@foo",
},
Labels: map[string]string{
"excluded": "me",
"app": "mysql-server",
},
},
RoleRef: rbacv1.RoleRef{
APIGroup: "rbac.authorization.k8s.io",
Kind: "Role",
Name: "role",
},
},
Want: `
# HELP kube_clusterrolebinding_annotations Kubernetes annotations converted to Prometheus labels.
# HELP kube_clusterrolebinding_labels Kubernetes labels converted to Prometheus labels.
# HELP kube_clusterrolebinding_info Information about clusterrolebinding.
# HELP kube_clusterrolebinding_metadata_resource_version Resource version representing a specific version of the clusterrolebinding.
# TYPE kube_clusterrolebinding_annotations gauge
# TYPE kube_clusterrolebinding_labels gauge
# TYPE kube_clusterrolebinding_info gauge
# TYPE kube_clusterrolebinding_metadata_resource_version gauge
kube_clusterrolebinding_annotations{annotation_app_k8s_io_owner="@foo",clusterrolebinding="clusterrolebinding1"} 1
kube_clusterrolebinding_labels{clusterrolebinding="clusterrolebinding1",label_app="mysql-server"} 1
kube_clusterrolebinding_info{clusterrolebinding="clusterrolebinding1",roleref_kind="Role",roleref_name="role"} 1
`,
MetricNames: []string{
"kube_clusterrolebinding_annotations",
"kube_clusterrolebinding_labels",
"kube_clusterrolebinding_info",
"kube_clusterrolebinding_metadata_resource_version",
},
},
{
Obj: &rbacv1.ClusterRoleBinding{
ObjectMeta: metav1.ObjectMeta{
Name: "clusterrolebinding2",
CreationTimestamp: metav1StartTime,
ResourceVersion: "10596",
},
RoleRef: rbacv1.RoleRef{
APIGroup: "rbac.authorization.k8s.io",
Kind: "Role",
Name: "role",
},
},
Want: `
# HELP kube_clusterrolebinding_created Unix creation timestamp
# HELP kube_clusterrolebinding_info Information about clusterrolebinding.
# HELP kube_clusterrolebinding_metadata_resource_version Resource version representing a specific version of the clusterrolebinding.
# TYPE kube_clusterrolebinding_created gauge
# TYPE kube_clusterrolebinding_info gauge
# TYPE kube_clusterrolebinding_metadata_resource_version gauge
kube_clusterrolebinding_info{clusterrolebinding="clusterrolebinding2",roleref_kind="Role",roleref_name="role"} 1
kube_clusterrolebinding_created{clusterrolebinding="clusterrolebinding2"} 1.501569018e+09
kube_clusterrolebinding_metadata_resource_version{clusterrolebinding="clusterrolebinding2"} 10596
`,
MetricNames: []string{"kube_clusterrolebinding_info", "kube_clusterrolebinding_created", "kube_clusterrolebinding_metadata_resource_version"},
},
}
for i, c := range cases {
c.Func = generator.ComposeMetricGenFuncs(clusterRoleBindingMetricFamilies(c.AllowAnnotationsList, c.AllowLabelsList))
c.Headers = generator.ExtractMetricFamilyHeaders(clusterRoleBindingMetricFamilies(c.AllowAnnotationsList, c.AllowLabelsList))
if err := c.run(); err != nil {
t.Errorf("unexpected collecting result in %vth run:\n%s", i, err)
}
}
}
```
|
```ruby
# frozen_string_literal: false
class LocalBarrier
def initialize(n)
@wait = Thread::Queue.new
@done = Thread::Queue.new
@keeper = begin_keeper(n)
end
def sync
@done.push(true)
@wait.pop
end
def join
@keeper.join
end
private
def begin_keeper(n)
Thread.start do
n.times do
@done.pop
end
n.times do
@wait.push(true)
end
end
end
end
n = 10
lb = LocalBarrier.new(n)
(n - 1).times do |i|
Thread.start do
sleep((rand(n) + 1) / 100.0)
print "#{i}: done\n"
lb.sync
print "#{i}: cont\n"
end
end
lb.sync
print "#{n-1}: cont\n"
# lb.join # [ruby-dev:30653]
print "exit.\n"
```
|
Self-Portrait or Portrait of an Old Man is an oil-on-canvas painting by El Greco, dating to between 1595 and 1600 and usually identified as a self-portrait. It shows the influence of Titian and Tintoretto, whose works El Greco studied in Venice. It is now in the Metropolitan Museum of Art in New York.
See also
List of works by El Greco
Bibliography
ÁLVAREZ LOPERA, José, El Greco, Madrid, Arlanza, 2005, Biblioteca «Descubrir el Arte», (colección «Grandes maestros»). .
SCHOLZ-HÄNSEL, Michael, El Greco, Colonia, Taschen, 2003. .
References
External links
ArteHistoria.com. «Autorretrato» [Consulta: 01.01.2011].
Portraits by El Greco
1590s paintings
El Greco
Paintings in the Metropolitan Museum of Art
Portraits of men
16th-century portraits
|
QSI International School of Ljubljana (QSIL) is a school in Slovenia that caters to students from 15 different nationalities ranging from 3 to 18 years of age. It was established in 1995 and instruction of its core classes are carried out in English by native English speakers. QSIL also offers Slovene (language and culture), German, French, and Spanish to all students from 5 to 18 years old. QSI International School of Ljubljana (QSIL) offers an academic program that is based on mastery learning. The program emphasizes mathematics, the sciences, social studies, English, art, fine arts, and PE. The location near a river and woods offers an opportunity for outdoor education as well. It is operated by Quality Schools International, a global consortium of 39 non-profit schools in 27 countries.
Location
QSI International School of Ljubljana is located in Ljubljana's Vič District. It is partially surrounded by woods, and the Mali Graben—a branch of the Gradaščica River—flows past the school to the east. The A1 Freeway runs about south of the school. The closest facilities include the Dolgi Most Sports Center (), immediately north of the school.
References
External links
QSI International School of Ljubljana website
International School of Ljubljana on Geopedia
International schools in Slovenia
Schools in Ljubljana
Primary schools in Slovenia
Secondary schools in Slovenia
Educational institutions established in 1995
1995 establishments in Slovenia
|
```xml
export const str = (obj: any) => {
if (!obj) {
return '';
}
if (typeof obj === 'string') {
return obj as string;
}
throw new Error(`Description: expected string, got: ${JSON.stringify(obj)}`);
};
```
|
```c++
//===- GVNHoist.cpp - Hoist scalar and load expressions -------------------===//
//
// See path_to_url for license information.
//
//===your_sha256_hash------===//
//
// This pass hoists expressions from branches to a common dominator. It uses
// GVN (global value numbering) to discover expressions computing the same
// values. The primary goals of code-hoisting are:
// 1. To reduce the code size.
// 2. In some cases reduce critical path (by exposing more ILP).
//
// The algorithm factors out the reachability of values such that multiple
// queries to find reachability of values are fast. This is based on finding the
// ANTIC points in the CFG which do not change during hoisting. The ANTIC points
// are basically the dominance-frontiers in the inverse graph. So we introduce a
// data structure (CHI nodes) to keep track of values flowing out of a basic
// block. We only do this for values with multiple occurrences in the function
// as they are the potential hoistable candidates. This approach allows us to
// hoist instructions to a basic block with more than two successors, as well as
// deal with infinite loops in a trivial way.
//
// Limitations: This pass does not hoist fully redundant expressions because
// they are already handled by GVN-PRE. It is advisable to run gvn-hoist before
// and after gvn-pre because gvn-pre creates opportunities for more instructions
// to be hoisted.
//
// Hoisting may affect the performance in some cases. To mitigate that, hoisting
// is disabled in the following cases.
// 1. Scalars across calls.
// 2. geps when corresponding load/store cannot be hoisted.
//===your_sha256_hash------===//
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/IteratedDominanceFrontier.h"
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/Analysis/MemorySSA.h"
#include "llvm/Analysis/MemorySSAUpdater.h"
#include "llvm/Analysis/PostDominators.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/Argument.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/CFG.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Use.h"
#include "llvm/IR/User.h"
#include "llvm/IR/Value.h"
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Scalar/GVN.h"
#include "llvm/Transforms/Utils/Local.h"
#include <algorithm>
#include <cassert>
#include <iterator>
#include <memory>
#include <utility>
#include <vector>
using namespace llvm;
#define DEBUG_TYPE "gvn-hoist"
STATISTIC(NumHoisted, "Number of instructions hoisted");
STATISTIC(NumRemoved, "Number of instructions removed");
STATISTIC(NumLoadsHoisted, "Number of loads hoisted");
STATISTIC(NumLoadsRemoved, "Number of loads removed");
STATISTIC(NumStoresHoisted, "Number of stores hoisted");
STATISTIC(NumStoresRemoved, "Number of stores removed");
STATISTIC(NumCallsHoisted, "Number of calls hoisted");
STATISTIC(NumCallsRemoved, "Number of calls removed");
static cl::opt<int>
MaxHoistedThreshold("gvn-max-hoisted", cl::Hidden, cl::init(-1),
cl::desc("Max number of instructions to hoist "
"(default unlimited = -1)"));
static cl::opt<int> MaxNumberOfBBSInPath(
"gvn-hoist-max-bbs", cl::Hidden, cl::init(4),
cl::desc("Max number of basic blocks on the path between "
"hoisting locations (default = 4, unlimited = -1)"));
static cl::opt<int> MaxDepthInBB(
"gvn-hoist-max-depth", cl::Hidden, cl::init(100),
cl::desc("Hoist instructions from the beginning of the BB up to the "
"maximum specified depth (default = 100, unlimited = -1)"));
static cl::opt<int>
MaxChainLength("gvn-hoist-max-chain-length", cl::Hidden, cl::init(10),
cl::desc("Maximum length of dependent chains to hoist "
"(default = 10, unlimited = -1)"));
namespace llvm {
using BBSideEffectsSet = DenseMap<const BasicBlock *, bool>;
using SmallVecInsn = SmallVector<Instruction *, 4>;
using SmallVecImplInsn = SmallVectorImpl<Instruction *>;
// Each element of a hoisting list contains the basic block where to hoist and
// a list of instructions to be hoisted.
using HoistingPointInfo = std::pair<BasicBlock *, SmallVecInsn>;
using HoistingPointList = SmallVector<HoistingPointInfo, 4>;
// A map from a pair of VNs to all the instructions with those VNs.
using VNType = std::pair<unsigned, uintptr_t>;
using VNtoInsns = DenseMap<VNType, SmallVector<Instruction *, 4>>;
// CHI keeps information about values flowing out of a basic block. It is
// similar to PHI but in the inverse graph, and used for outgoing values on each
// edge. For conciseness, it is computed only for instructions with multiple
// occurrences in the CFG because they are the only hoistable candidates.
// A (CHI[{V, B, I1}, {V, C, I2}]
// / \
// / \
// B(I1) C (I2)
// The Value number for both I1 and I2 is V, the CHI node will save the
// instruction as well as the edge where the value is flowing to.
struct CHIArg {
VNType VN;
// Edge destination (shows the direction of flow), may not be where the I is.
BasicBlock *Dest;
// The instruction (VN) which uses the values flowing out of CHI.
Instruction *I;
bool operator==(const CHIArg &A) const { return VN == A.VN; }
bool operator!=(const CHIArg &A) const { return !(*this == A); }
};
using CHIIt = SmallVectorImpl<CHIArg>::iterator;
using CHIArgs = iterator_range<CHIIt>;
using OutValuesType = DenseMap<BasicBlock *, SmallVector<CHIArg, 2>>;
using InValuesType =
DenseMap<BasicBlock *, SmallVector<std::pair<VNType, Instruction *>, 2>>;
// An invalid value number Used when inserting a single value number into
// VNtoInsns.
enum : uintptr_t { InvalidVN = ~(uintptr_t)2 };
// Records all scalar instructions candidate for code hoisting.
class InsnInfo {
VNtoInsns VNtoScalars;
public:
// Inserts I and its value number in VNtoScalars.
void insert(Instruction *I, GVNPass::ValueTable &VN) {
// Scalar instruction.
unsigned V = VN.lookupOrAdd(I);
VNtoScalars[{V, InvalidVN}].push_back(I);
}
const VNtoInsns &getVNTable() const { return VNtoScalars; }
};
// Records all load instructions candidate for code hoisting.
class LoadInfo {
VNtoInsns VNtoLoads;
public:
// Insert Load and the value number of its memory address in VNtoLoads.
void insert(LoadInst *Load, GVNPass::ValueTable &VN) {
if (Load->isSimple()) {
unsigned V = VN.lookupOrAdd(Load->getPointerOperand());
// With opaque pointers we may have loads from the same pointer with
// different result types, which should be disambiguated.
VNtoLoads[{V, (uintptr_t)Load->getType()}].push_back(Load);
}
}
const VNtoInsns &getVNTable() const { return VNtoLoads; }
};
// Records all store instructions candidate for code hoisting.
class StoreInfo {
VNtoInsns VNtoStores;
public:
// Insert the Store and a hash number of the store address and the stored
// value in VNtoStores.
void insert(StoreInst *Store, GVNPass::ValueTable &VN) {
if (!Store->isSimple())
return;
// Hash the store address and the stored value.
Value *Ptr = Store->getPointerOperand();
Value *Val = Store->getValueOperand();
VNtoStores[{VN.lookupOrAdd(Ptr), VN.lookupOrAdd(Val)}].push_back(Store);
}
const VNtoInsns &getVNTable() const { return VNtoStores; }
};
// Records all call instructions candidate for code hoisting.
class CallInfo {
VNtoInsns VNtoCallsScalars;
VNtoInsns VNtoCallsLoads;
VNtoInsns VNtoCallsStores;
public:
// Insert Call and its value numbering in one of the VNtoCalls* containers.
void insert(CallInst *Call, GVNPass::ValueTable &VN) {
// A call that doesNotAccessMemory is handled as a Scalar,
// onlyReadsMemory will be handled as a Load instruction,
// all other calls will be handled as stores.
unsigned V = VN.lookupOrAdd(Call);
auto Entry = std::make_pair(V, InvalidVN);
if (Call->doesNotAccessMemory())
VNtoCallsScalars[Entry].push_back(Call);
else if (Call->onlyReadsMemory())
VNtoCallsLoads[Entry].push_back(Call);
else
VNtoCallsStores[Entry].push_back(Call);
}
const VNtoInsns &getScalarVNTable() const { return VNtoCallsScalars; }
const VNtoInsns &getLoadVNTable() const { return VNtoCallsLoads; }
const VNtoInsns &getStoreVNTable() const { return VNtoCallsStores; }
};
static void combineKnownMetadata(Instruction *ReplInst, Instruction *I) {
static const unsigned KnownIDs[] = {LLVMContext::MD_tbaa,
LLVMContext::MD_alias_scope,
LLVMContext::MD_noalias,
LLVMContext::MD_range,
LLVMContext::MD_fpmath,
LLVMContext::MD_invariant_load,
LLVMContext::MD_invariant_group,
LLVMContext::MD_access_group};
combineMetadata(ReplInst, I, KnownIDs, true);
}
// This pass hoists common computations across branches sharing common
// dominator. The primary goal is to reduce the code size, and in some
// cases reduce critical path (by exposing more ILP).
class GVNHoist {
public:
GVNHoist(DominatorTree *DT, PostDominatorTree *PDT, AliasAnalysis *AA,
MemoryDependenceResults *MD, MemorySSA *MSSA)
: DT(DT), PDT(PDT), AA(AA), MD(MD), MSSA(MSSA),
MSSAUpdater(std::make_unique<MemorySSAUpdater>(MSSA)) {
MSSA->ensureOptimizedUses();
}
bool run(Function &F);
// Copied from NewGVN.cpp
// This function provides global ranking of operations so that we can place
// them in a canonical order. Note that rank alone is not necessarily enough
// for a complete ordering, as constants all have the same rank. However,
// generally, we will simplify an operation with all constants so that it
// doesn't matter what order they appear in.
unsigned int rank(const Value *V) const;
private:
GVNPass::ValueTable VN;
DominatorTree *DT;
PostDominatorTree *PDT;
AliasAnalysis *AA;
MemoryDependenceResults *MD;
MemorySSA *MSSA;
std::unique_ptr<MemorySSAUpdater> MSSAUpdater;
DenseMap<const Value *, unsigned> DFSNumber;
BBSideEffectsSet BBSideEffects;
DenseSet<const BasicBlock *> HoistBarrier;
SmallVector<BasicBlock *, 32> IDFBlocks;
unsigned NumFuncArgs;
const bool HoistingGeps = false;
enum InsKind { Unknown, Scalar, Load, Store };
// Return true when there are exception handling in BB.
bool hasEH(const BasicBlock *BB);
// Return true when I1 appears before I2 in the instructions of BB.
bool firstInBB(const Instruction *I1, const Instruction *I2) {
assert(I1->getParent() == I2->getParent());
unsigned I1DFS = DFSNumber.lookup(I1);
unsigned I2DFS = DFSNumber.lookup(I2);
assert(I1DFS && I2DFS);
return I1DFS < I2DFS;
}
// Return true when there are memory uses of Def in BB.
bool hasMemoryUse(const Instruction *NewPt, MemoryDef *Def,
const BasicBlock *BB);
bool hasEHhelper(const BasicBlock *BB, const BasicBlock *SrcBB,
int &NBBsOnAllPaths);
// Return true when there are exception handling or loads of memory Def
// between Def and NewPt. This function is only called for stores: Def is
// the MemoryDef of the store to be hoisted.
// Decrement by 1 NBBsOnAllPaths for each block between HoistPt and BB, and
// return true when the counter NBBsOnAllPaths reaces 0, except when it is
// initialized to -1 which is unlimited.
bool hasEHOrLoadsOnPath(const Instruction *NewPt, MemoryDef *Def,
int &NBBsOnAllPaths);
// Return true when there are exception handling between HoistPt and BB.
// Decrement by 1 NBBsOnAllPaths for each block between HoistPt and BB, and
// return true when the counter NBBsOnAllPaths reaches 0, except when it is
// initialized to -1 which is unlimited.
bool hasEHOnPath(const BasicBlock *HoistPt, const BasicBlock *SrcBB,
int &NBBsOnAllPaths);
// Return true when it is safe to hoist a memory load or store U from OldPt
// to NewPt.
bool safeToHoistLdSt(const Instruction *NewPt, const Instruction *OldPt,
MemoryUseOrDef *U, InsKind K, int &NBBsOnAllPaths);
// Return true when it is safe to hoist scalar instructions from all blocks in
// WL to HoistBB.
bool safeToHoistScalar(const BasicBlock *HoistBB, const BasicBlock *BB,
int &NBBsOnAllPaths) {
return !hasEHOnPath(HoistBB, BB, NBBsOnAllPaths);
}
// In the inverse CFG, the dominance frontier of basic block (BB) is the
// point where ANTIC needs to be computed for instructions which are going
// to be hoisted. Since this point does not change during gvn-hoist,
// we compute it only once (on demand).
// The ides is inspired from:
// "Partial Redundancy Elimination in SSA Form"
// ROBERT KENNEDY, SUN CHAN, SHIN-MING LIU, RAYMOND LO, PENG TU and FRED CHOW
// They use similar idea in the forward graph to find fully redundant and
// partially redundant expressions, here it is used in the inverse graph to
// find fully anticipable instructions at merge point (post-dominator in
// the inverse CFG).
// Returns the edge via which an instruction in BB will get the values from.
// Returns true when the values are flowing out to each edge.
bool valueAnticipable(CHIArgs C, Instruction *TI) const;
// Check if it is safe to hoist values tracked by CHI in the range
// [Begin, End) and accumulate them in Safe.
void checkSafety(CHIArgs C, BasicBlock *BB, InsKind K,
SmallVectorImpl<CHIArg> &Safe);
using RenameStackType = DenseMap<VNType, SmallVector<Instruction *, 2>>;
// Push all the VNs corresponding to BB into RenameStack.
void fillRenameStack(BasicBlock *BB, InValuesType &ValueBBs,
RenameStackType &RenameStack);
void fillChiArgs(BasicBlock *BB, OutValuesType &CHIBBs,
RenameStackType &RenameStack);
// Walk the post-dominator tree top-down and use a stack for each value to
// store the last value you see. When you hit a CHI from a given edge, the
// value to use as the argument is at the top of the stack, add the value to
// CHI and pop.
void insertCHI(InValuesType &ValueBBs, OutValuesType &CHIBBs) {
auto Root = PDT->getNode(nullptr);
if (!Root)
return;
// Depth first walk on PDom tree to fill the CHIargs at each PDF.
for (auto *Node : depth_first(Root)) {
BasicBlock *BB = Node->getBlock();
if (!BB)
continue;
RenameStackType RenameStack;
// Collect all values in BB and push to stack.
fillRenameStack(BB, ValueBBs, RenameStack);
// Fill outgoing values in each CHI corresponding to BB.
fillChiArgs(BB, CHIBBs, RenameStack);
}
}
// Walk all the CHI-nodes to find ones which have a empty-entry and remove
// them Then collect all the instructions which are safe to hoist and see if
// they form a list of anticipable values. OutValues contains CHIs
// corresponding to each basic block.
void findHoistableCandidates(OutValuesType &CHIBBs, InsKind K,
HoistingPointList &HPL);
// Compute insertion points for each values which can be fully anticipated at
// a dominator. HPL contains all such values.
void computeInsertionPoints(const VNtoInsns &Map, HoistingPointList &HPL,
InsKind K) {
// Sort VNs based on their rankings
std::vector<VNType> Ranks;
for (const auto &Entry : Map) {
Ranks.push_back(Entry.first);
}
// TODO: Remove fully-redundant expressions.
// Get instruction from the Map, assume that all the Instructions
// with same VNs have same rank (this is an approximation).
llvm::sort(Ranks, [this, &Map](const VNType &r1, const VNType &r2) {
return (rank(*Map.lookup(r1).begin()) < rank(*Map.lookup(r2).begin()));
});
// - Sort VNs according to their rank, and start with lowest ranked VN
// - Take a VN and for each instruction with same VN
// - Find the dominance frontier in the inverse graph (PDF)
// - Insert the chi-node at PDF
// - Remove the chi-nodes with missing entries
// - Remove values from CHI-nodes which do not truly flow out, e.g.,
// modified along the path.
// - Collect the remaining values that are still anticipable
SmallVector<BasicBlock *, 2> IDFBlocks;
ReverseIDFCalculator IDFs(*PDT);
OutValuesType OutValue;
InValuesType InValue;
for (const auto &R : Ranks) {
const SmallVecInsn &V = Map.lookup(R);
if (V.size() < 2)
continue;
const VNType &VN = R;
SmallPtrSet<BasicBlock *, 2> VNBlocks;
for (const auto &I : V) {
BasicBlock *BBI = I->getParent();
if (!hasEH(BBI))
VNBlocks.insert(BBI);
}
// Compute the Post Dominance Frontiers of each basic block
// The dominance frontier of a live block X in the reverse
// control graph is the set of blocks upon which X is control
// dependent. The following sequence computes the set of blocks
// which currently have dead terminators that are control
// dependence sources of a block which is in NewLiveBlocks.
IDFs.setDefiningBlocks(VNBlocks);
IDFBlocks.clear();
IDFs.calculate(IDFBlocks);
// Make a map of BB vs instructions to be hoisted.
for (unsigned i = 0; i < V.size(); ++i) {
InValue[V[i]->getParent()].push_back(std::make_pair(VN, V[i]));
}
// Insert empty CHI node for this VN. This is used to factor out
// basic blocks where the ANTIC can potentially change.
CHIArg EmptyChi = {VN, nullptr, nullptr};
for (auto *IDFBB : IDFBlocks) {
for (unsigned i = 0; i < V.size(); ++i) {
// Ignore spurious PDFs.
if (DT->properlyDominates(IDFBB, V[i]->getParent())) {
OutValue[IDFBB].push_back(EmptyChi);
LLVM_DEBUG(dbgs() << "\nInserting a CHI for BB: "
<< IDFBB->getName() << ", for Insn: " << *V[i]);
}
}
}
}
// Insert CHI args at each PDF to iterate on factored graph of
// control dependence.
insertCHI(InValue, OutValue);
// Using the CHI args inserted at each PDF, find fully anticipable values.
findHoistableCandidates(OutValue, K, HPL);
}
// Return true when all operands of Instr are available at insertion point
// HoistPt. When limiting the number of hoisted expressions, one could hoist
// a load without hoisting its access function. So before hoisting any
// expression, make sure that all its operands are available at insert point.
bool allOperandsAvailable(const Instruction *I,
const BasicBlock *HoistPt) const;
// Same as allOperandsAvailable with recursive check for GEP operands.
bool allGepOperandsAvailable(const Instruction *I,
const BasicBlock *HoistPt) const;
// Make all operands of the GEP available.
void makeGepsAvailable(Instruction *Repl, BasicBlock *HoistPt,
const SmallVecInsn &InstructionsToHoist,
Instruction *Gep) const;
void updateAlignment(Instruction *I, Instruction *Repl);
// Remove all the instructions in Candidates and replace their usage with
// Repl. Returns the number of instructions removed.
unsigned rauw(const SmallVecInsn &Candidates, Instruction *Repl,
MemoryUseOrDef *NewMemAcc);
// Replace all Memory PHI usage with NewMemAcc.
void raMPHIuw(MemoryUseOrDef *NewMemAcc);
// Remove all other instructions and replace them with Repl.
unsigned removeAndReplace(const SmallVecInsn &Candidates, Instruction *Repl,
BasicBlock *DestBB, bool MoveAccess);
// In the case Repl is a load or a store, we make all their GEPs
// available: GEPs are not hoisted by default to avoid the address
// computations to be hoisted without the associated load or store.
bool makeGepOperandsAvailable(Instruction *Repl, BasicBlock *HoistPt,
const SmallVecInsn &InstructionsToHoist) const;
std::pair<unsigned, unsigned> hoist(HoistingPointList &HPL);
// Hoist all expressions. Returns Number of scalars hoisted
// and number of non-scalars hoisted.
std::pair<unsigned, unsigned> hoistExpressions(Function &F);
};
class GVNHoistLegacyPass : public FunctionPass {
public:
static char ID;
GVNHoistLegacyPass() : FunctionPass(ID) {
initializeGVNHoistLegacyPassPass(*PassRegistry::getPassRegistry());
}
bool runOnFunction(Function &F) override {
if (skipFunction(F))
return false;
auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
auto &MD = getAnalysis<MemoryDependenceWrapperPass>().getMemDep();
auto &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA();
GVNHoist G(&DT, &PDT, &AA, &MD, &MSSA);
return G.run(F);
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<DominatorTreeWrapperPass>();
AU.addRequired<PostDominatorTreeWrapperPass>();
AU.addRequired<AAResultsWrapperPass>();
AU.addRequired<MemoryDependenceWrapperPass>();
AU.addRequired<MemorySSAWrapperPass>();
AU.addPreserved<DominatorTreeWrapperPass>();
AU.addPreserved<MemorySSAWrapperPass>();
AU.addPreserved<GlobalsAAWrapperPass>();
}
};
bool GVNHoist::run(Function &F) {
NumFuncArgs = F.arg_size();
VN.setDomTree(DT);
VN.setAliasAnalysis(AA);
VN.setMemDep(MD);
bool Res = false;
// Perform DFS Numbering of instructions.
unsigned BBI = 0;
for (const BasicBlock *BB : depth_first(&F.getEntryBlock())) {
DFSNumber[BB] = ++BBI;
unsigned I = 0;
for (const auto &Inst : *BB)
DFSNumber[&Inst] = ++I;
}
int ChainLength = 0;
// FIXME: use lazy evaluation of VN to avoid the fix-point computation.
while (true) {
if (MaxChainLength != -1 && ++ChainLength >= MaxChainLength)
return Res;
auto HoistStat = hoistExpressions(F);
if (HoistStat.first + HoistStat.second == 0)
return Res;
if (HoistStat.second > 0)
// To address a limitation of the current GVN, we need to rerun the
// hoisting after we hoisted loads or stores in order to be able to
// hoist all scalars dependent on the hoisted ld/st.
VN.clear();
Res = true;
}
return Res;
}
unsigned int GVNHoist::rank(const Value *V) const {
// Prefer constants to undef to anything else
// Undef is a constant, have to check it first.
// Prefer smaller constants to constantexprs
if (isa<ConstantExpr>(V))
return 2;
if (isa<UndefValue>(V))
return 1;
if (isa<Constant>(V))
return 0;
else if (auto *A = dyn_cast<Argument>(V))
return 3 + A->getArgNo();
// Need to shift the instruction DFS by number of arguments + 3 to account
// for the constant and argument ranking above.
auto Result = DFSNumber.lookup(V);
if (Result > 0)
return 4 + NumFuncArgs + Result;
// Unreachable or something else, just return a really large number.
return ~0;
}
bool GVNHoist::hasEH(const BasicBlock *BB) {
auto It = BBSideEffects.find(BB);
if (It != BBSideEffects.end())
return It->second;
if (BB->isEHPad() || BB->hasAddressTaken()) {
BBSideEffects[BB] = true;
return true;
}
if (BB->getTerminator()->mayThrow()) {
BBSideEffects[BB] = true;
return true;
}
BBSideEffects[BB] = false;
return false;
}
bool GVNHoist::hasMemoryUse(const Instruction *NewPt, MemoryDef *Def,
const BasicBlock *BB) {
const MemorySSA::AccessList *Acc = MSSA->getBlockAccesses(BB);
if (!Acc)
return false;
Instruction *OldPt = Def->getMemoryInst();
const BasicBlock *OldBB = OldPt->getParent();
const BasicBlock *NewBB = NewPt->getParent();
bool ReachedNewPt = false;
for (const MemoryAccess &MA : *Acc)
if (const MemoryUse *MU = dyn_cast<MemoryUse>(&MA)) {
Instruction *Insn = MU->getMemoryInst();
// Do not check whether MU aliases Def when MU occurs after OldPt.
if (BB == OldBB && firstInBB(OldPt, Insn))
break;
// Do not check whether MU aliases Def when MU occurs before NewPt.
if (BB == NewBB) {
if (!ReachedNewPt) {
if (firstInBB(Insn, NewPt))
continue;
ReachedNewPt = true;
}
}
if (MemorySSAUtil::defClobbersUseOrDef(Def, MU, *AA))
return true;
}
return false;
}
bool GVNHoist::hasEHhelper(const BasicBlock *BB, const BasicBlock *SrcBB,
int &NBBsOnAllPaths) {
// Stop walk once the limit is reached.
if (NBBsOnAllPaths == 0)
return true;
// Impossible to hoist with exceptions on the path.
if (hasEH(BB))
return true;
// No such instruction after HoistBarrier in a basic block was
// selected for hoisting so instructions selected within basic block with
// a hoist barrier can be hoisted.
if ((BB != SrcBB) && HoistBarrier.count(BB))
return true;
return false;
}
bool GVNHoist::hasEHOrLoadsOnPath(const Instruction *NewPt, MemoryDef *Def,
int &NBBsOnAllPaths) {
const BasicBlock *NewBB = NewPt->getParent();
const BasicBlock *OldBB = Def->getBlock();
assert(DT->dominates(NewBB, OldBB) && "invalid path");
assert(DT->dominates(Def->getDefiningAccess()->getBlock(), NewBB) &&
"def does not dominate new hoisting point");
// Walk all basic blocks reachable in depth-first iteration on the inverse
// CFG from OldBB to NewBB. These blocks are all the blocks that may be
// executed between the execution of NewBB and OldBB. Hoisting an expression
// from OldBB into NewBB has to be safe on all execution paths.
for (auto I = idf_begin(OldBB), E = idf_end(OldBB); I != E;) {
const BasicBlock *BB = *I;
if (BB == NewBB) {
// Stop traversal when reaching HoistPt.
I.skipChildren();
continue;
}
if (hasEHhelper(BB, OldBB, NBBsOnAllPaths))
return true;
// Check that we do not move a store past loads.
if (hasMemoryUse(NewPt, Def, BB))
return true;
// -1 is unlimited number of blocks on all paths.
if (NBBsOnAllPaths != -1)
--NBBsOnAllPaths;
++I;
}
return false;
}
bool GVNHoist::hasEHOnPath(const BasicBlock *HoistPt, const BasicBlock *SrcBB,
int &NBBsOnAllPaths) {
assert(DT->dominates(HoistPt, SrcBB) && "Invalid path");
// Walk all basic blocks reachable in depth-first iteration on
// the inverse CFG from BBInsn to NewHoistPt. These blocks are all the
// blocks that may be executed between the execution of NewHoistPt and
// BBInsn. Hoisting an expression from BBInsn into NewHoistPt has to be safe
// on all execution paths.
for (auto I = idf_begin(SrcBB), E = idf_end(SrcBB); I != E;) {
const BasicBlock *BB = *I;
if (BB == HoistPt) {
// Stop traversal when reaching NewHoistPt.
I.skipChildren();
continue;
}
if (hasEHhelper(BB, SrcBB, NBBsOnAllPaths))
return true;
// -1 is unlimited number of blocks on all paths.
if (NBBsOnAllPaths != -1)
--NBBsOnAllPaths;
++I;
}
return false;
}
bool GVNHoist::safeToHoistLdSt(const Instruction *NewPt,
const Instruction *OldPt, MemoryUseOrDef *U,
GVNHoist::InsKind K, int &NBBsOnAllPaths) {
// In place hoisting is safe.
if (NewPt == OldPt)
return true;
const BasicBlock *NewBB = NewPt->getParent();
const BasicBlock *OldBB = OldPt->getParent();
const BasicBlock *UBB = U->getBlock();
// Check for dependences on the Memory SSA.
MemoryAccess *D = U->getDefiningAccess();
BasicBlock *DBB = D->getBlock();
if (DT->properlyDominates(NewBB, DBB))
// Cannot move the load or store to NewBB above its definition in DBB.
return false;
if (NewBB == DBB && !MSSA->isLiveOnEntryDef(D))
if (auto *UD = dyn_cast<MemoryUseOrDef>(D))
if (!firstInBB(UD->getMemoryInst(), NewPt))
// Cannot move the load or store to NewPt above its definition in D.
return false;
// Check for unsafe hoistings due to side effects.
if (K == InsKind::Store) {
if (hasEHOrLoadsOnPath(NewPt, cast<MemoryDef>(U), NBBsOnAllPaths))
return false;
} else if (hasEHOnPath(NewBB, OldBB, NBBsOnAllPaths))
return false;
if (UBB == NewBB) {
if (DT->properlyDominates(DBB, NewBB))
return true;
assert(UBB == DBB);
assert(MSSA->locallyDominates(D, U));
}
// No side effects: it is safe to hoist.
return true;
}
bool GVNHoist::valueAnticipable(CHIArgs C, Instruction *TI) const {
if (TI->getNumSuccessors() > (unsigned)size(C))
return false; // Not enough args in this CHI.
for (auto CHI : C) {
// Find if all the edges have values flowing out of BB.
if (!llvm::is_contained(successors(TI), CHI.Dest))
return false;
}
return true;
}
void GVNHoist::checkSafety(CHIArgs C, BasicBlock *BB, GVNHoist::InsKind K,
SmallVectorImpl<CHIArg> &Safe) {
int NumBBsOnAllPaths = MaxNumberOfBBSInPath;
for (auto CHI : C) {
Instruction *Insn = CHI.I;
if (!Insn) // No instruction was inserted in this CHI.
continue;
if (K == InsKind::Scalar) {
if (safeToHoistScalar(BB, Insn->getParent(), NumBBsOnAllPaths))
Safe.push_back(CHI);
} else {
auto *T = BB->getTerminator();
if (MemoryUseOrDef *UD = MSSA->getMemoryAccess(Insn))
if (safeToHoistLdSt(T, Insn, UD, K, NumBBsOnAllPaths))
Safe.push_back(CHI);
}
}
}
void GVNHoist::fillRenameStack(BasicBlock *BB, InValuesType &ValueBBs,
GVNHoist::RenameStackType &RenameStack) {
auto it1 = ValueBBs.find(BB);
if (it1 != ValueBBs.end()) {
// Iterate in reverse order to keep lower ranked values on the top.
LLVM_DEBUG(dbgs() << "\nVisiting: " << BB->getName()
<< " for pushing instructions on stack";);
for (std::pair<VNType, Instruction *> &VI : reverse(it1->second)) {
// Get the value of instruction I
LLVM_DEBUG(dbgs() << "\nPushing on stack: " << *VI.second);
RenameStack[VI.first].push_back(VI.second);
}
}
}
void GVNHoist::fillChiArgs(BasicBlock *BB, OutValuesType &CHIBBs,
GVNHoist::RenameStackType &RenameStack) {
// For each *predecessor* (because Post-DOM) of BB check if it has a CHI
for (auto *Pred : predecessors(BB)) {
auto P = CHIBBs.find(Pred);
if (P == CHIBBs.end()) {
continue;
}
LLVM_DEBUG(dbgs() << "\nLooking at CHIs in: " << Pred->getName(););
// A CHI is found (BB -> Pred is an edge in the CFG)
// Pop the stack until Top(V) = Ve.
auto &VCHI = P->second;
for (auto It = VCHI.begin(), E = VCHI.end(); It != E;) {
CHIArg &C = *It;
if (!C.Dest) {
auto si = RenameStack.find(C.VN);
// The Basic Block where CHI is must dominate the value we want to
// track in a CHI. In the PDom walk, there can be values in the
// stack which are not control dependent e.g., nested loop.
if (si != RenameStack.end() && si->second.size() &&
DT->properlyDominates(Pred, si->second.back()->getParent())) {
C.Dest = BB; // Assign the edge
C.I = si->second.pop_back_val(); // Assign the argument
LLVM_DEBUG(dbgs()
<< "\nCHI Inserted in BB: " << C.Dest->getName() << *C.I
<< ", VN: " << C.VN.first << ", " << C.VN.second);
}
// Move to next CHI of a different value
It = std::find_if(It, VCHI.end(), [It](CHIArg &A) { return A != *It; });
} else
++It;
}
}
}
void GVNHoist::findHoistableCandidates(OutValuesType &CHIBBs,
GVNHoist::InsKind K,
HoistingPointList &HPL) {
auto cmpVN = [](const CHIArg &A, const CHIArg &B) { return A.VN < B.VN; };
// CHIArgs now have the outgoing values, so check for anticipability and
// accumulate hoistable candidates in HPL.
for (std::pair<BasicBlock *, SmallVector<CHIArg, 2>> &A : CHIBBs) {
BasicBlock *BB = A.first;
SmallVectorImpl<CHIArg> &CHIs = A.second;
// Vector of PHIs contains PHIs for different instructions.
// Sort the args according to their VNs, such that identical
// instructions are together.
llvm::stable_sort(CHIs, cmpVN);
auto TI = BB->getTerminator();
auto B = CHIs.begin();
// [PreIt, PHIIt) form a range of CHIs which have identical VNs.
auto PHIIt = llvm::find_if(CHIs, [B](CHIArg &A) { return A != *B; });
auto PrevIt = CHIs.begin();
while (PrevIt != PHIIt) {
// Collect values which satisfy safety checks.
SmallVector<CHIArg, 2> Safe;
// We check for safety first because there might be multiple values in
// the same path, some of which are not safe to be hoisted, but overall
// each edge has at least one value which can be hoisted, making the
// value anticipable along that path.
checkSafety(make_range(PrevIt, PHIIt), BB, K, Safe);
// List of safe values should be anticipable at TI.
if (valueAnticipable(make_range(Safe.begin(), Safe.end()), TI)) {
HPL.push_back({BB, SmallVecInsn()});
SmallVecInsn &V = HPL.back().second;
for (auto B : Safe)
V.push_back(B.I);
}
// Check other VNs
PrevIt = PHIIt;
PHIIt = std::find_if(PrevIt, CHIs.end(),
[PrevIt](CHIArg &A) { return A != *PrevIt; });
}
}
}
bool GVNHoist::allOperandsAvailable(const Instruction *I,
const BasicBlock *HoistPt) const {
for (const Use &Op : I->operands())
if (const auto *Inst = dyn_cast<Instruction>(&Op))
if (!DT->dominates(Inst->getParent(), HoistPt))
return false;
return true;
}
bool GVNHoist::allGepOperandsAvailable(const Instruction *I,
const BasicBlock *HoistPt) const {
for (const Use &Op : I->operands())
if (const auto *Inst = dyn_cast<Instruction>(&Op))
if (!DT->dominates(Inst->getParent(), HoistPt)) {
if (const GetElementPtrInst *GepOp =
dyn_cast<GetElementPtrInst>(Inst)) {
if (!allGepOperandsAvailable(GepOp, HoistPt))
return false;
// Gep is available if all operands of GepOp are available.
} else {
// Gep is not available if it has operands other than GEPs that are
// defined in blocks not dominating HoistPt.
return false;
}
}
return true;
}
void GVNHoist::makeGepsAvailable(Instruction *Repl, BasicBlock *HoistPt,
const SmallVecInsn &InstructionsToHoist,
Instruction *Gep) const {
assert(allGepOperandsAvailable(Gep, HoistPt) && "GEP operands not available");
Instruction *ClonedGep = Gep->clone();
for (unsigned i = 0, e = Gep->getNumOperands(); i != e; ++i)
if (Instruction *Op = dyn_cast<Instruction>(Gep->getOperand(i))) {
// Check whether the operand is already available.
if (DT->dominates(Op->getParent(), HoistPt))
continue;
// As a GEP can refer to other GEPs, recursively make all the operands
// of this GEP available at HoistPt.
if (GetElementPtrInst *GepOp = dyn_cast<GetElementPtrInst>(Op))
makeGepsAvailable(ClonedGep, HoistPt, InstructionsToHoist, GepOp);
}
// Copy Gep and replace its uses in Repl with ClonedGep.
ClonedGep->insertBefore(HoistPt->getTerminator());
// Conservatively discard any optimization hints, they may differ on the
// other paths.
ClonedGep->dropUnknownNonDebugMetadata();
// If we have optimization hints which agree with each other along different
// paths, preserve them.
for (const Instruction *OtherInst : InstructionsToHoist) {
const GetElementPtrInst *OtherGep;
if (auto *OtherLd = dyn_cast<LoadInst>(OtherInst))
OtherGep = cast<GetElementPtrInst>(OtherLd->getPointerOperand());
else
OtherGep = cast<GetElementPtrInst>(
cast<StoreInst>(OtherInst)->getPointerOperand());
ClonedGep->andIRFlags(OtherGep);
}
// Replace uses of Gep with ClonedGep in Repl.
Repl->replaceUsesOfWith(Gep, ClonedGep);
}
void GVNHoist::updateAlignment(Instruction *I, Instruction *Repl) {
if (auto *ReplacementLoad = dyn_cast<LoadInst>(Repl)) {
ReplacementLoad->setAlignment(
std::min(ReplacementLoad->getAlign(), cast<LoadInst>(I)->getAlign()));
++NumLoadsRemoved;
} else if (auto *ReplacementStore = dyn_cast<StoreInst>(Repl)) {
ReplacementStore->setAlignment(
std::min(ReplacementStore->getAlign(), cast<StoreInst>(I)->getAlign()));
++NumStoresRemoved;
} else if (auto *ReplacementAlloca = dyn_cast<AllocaInst>(Repl)) {
ReplacementAlloca->setAlignment(std::max(ReplacementAlloca->getAlign(),
cast<AllocaInst>(I)->getAlign()));
} else if (isa<CallInst>(Repl)) {
++NumCallsRemoved;
}
}
unsigned GVNHoist::rauw(const SmallVecInsn &Candidates, Instruction *Repl,
MemoryUseOrDef *NewMemAcc) {
unsigned NR = 0;
for (Instruction *I : Candidates) {
if (I != Repl) {
++NR;
updateAlignment(I, Repl);
if (NewMemAcc) {
// Update the uses of the old MSSA access with NewMemAcc.
MemoryAccess *OldMA = MSSA->getMemoryAccess(I);
OldMA->replaceAllUsesWith(NewMemAcc);
MSSAUpdater->removeMemoryAccess(OldMA);
}
Repl->andIRFlags(I);
combineKnownMetadata(Repl, I);
I->replaceAllUsesWith(Repl);
// Also invalidate the Alias Analysis cache.
MD->removeInstruction(I);
I->eraseFromParent();
}
}
return NR;
}
void GVNHoist::raMPHIuw(MemoryUseOrDef *NewMemAcc) {
SmallPtrSet<MemoryPhi *, 4> UsePhis;
for (User *U : NewMemAcc->users())
if (MemoryPhi *Phi = dyn_cast<MemoryPhi>(U))
UsePhis.insert(Phi);
for (MemoryPhi *Phi : UsePhis) {
auto In = Phi->incoming_values();
if (llvm::all_of(In, [&](Use &U) { return U == NewMemAcc; })) {
Phi->replaceAllUsesWith(NewMemAcc);
MSSAUpdater->removeMemoryAccess(Phi);
}
}
}
unsigned GVNHoist::removeAndReplace(const SmallVecInsn &Candidates,
Instruction *Repl, BasicBlock *DestBB,
bool MoveAccess) {
MemoryUseOrDef *NewMemAcc = MSSA->getMemoryAccess(Repl);
if (MoveAccess && NewMemAcc) {
// The definition of this ld/st will not change: ld/st hoisting is
// legal when the ld/st is not moved past its current definition.
MSSAUpdater->moveToPlace(NewMemAcc, DestBB, MemorySSA::BeforeTerminator);
}
// Replace all other instructions with Repl with memory access NewMemAcc.
unsigned NR = rauw(Candidates, Repl, NewMemAcc);
// Remove MemorySSA phi nodes with the same arguments.
if (NewMemAcc)
raMPHIuw(NewMemAcc);
return NR;
}
bool GVNHoist::makeGepOperandsAvailable(
Instruction *Repl, BasicBlock *HoistPt,
const SmallVecInsn &InstructionsToHoist) const {
// Check whether the GEP of a ld/st can be synthesized at HoistPt.
GetElementPtrInst *Gep = nullptr;
Instruction *Val = nullptr;
if (auto *Ld = dyn_cast<LoadInst>(Repl)) {
Gep = dyn_cast<GetElementPtrInst>(Ld->getPointerOperand());
} else if (auto *St = dyn_cast<StoreInst>(Repl)) {
Gep = dyn_cast<GetElementPtrInst>(St->getPointerOperand());
Val = dyn_cast<Instruction>(St->getValueOperand());
// Check that the stored value is available.
if (Val) {
if (isa<GetElementPtrInst>(Val)) {
// Check whether we can compute the GEP at HoistPt.
if (!allGepOperandsAvailable(Val, HoistPt))
return false;
} else if (!DT->dominates(Val->getParent(), HoistPt))
return false;
}
}
// Check whether we can compute the Gep at HoistPt.
if (!Gep || !allGepOperandsAvailable(Gep, HoistPt))
return false;
makeGepsAvailable(Repl, HoistPt, InstructionsToHoist, Gep);
if (Val && isa<GetElementPtrInst>(Val))
makeGepsAvailable(Repl, HoistPt, InstructionsToHoist, Val);
return true;
}
std::pair<unsigned, unsigned> GVNHoist::hoist(HoistingPointList &HPL) {
unsigned NI = 0, NL = 0, NS = 0, NC = 0, NR = 0;
for (const HoistingPointInfo &HP : HPL) {
// Find out whether we already have one of the instructions in HoistPt,
// in which case we do not have to move it.
BasicBlock *DestBB = HP.first;
const SmallVecInsn &InstructionsToHoist = HP.second;
Instruction *Repl = nullptr;
for (Instruction *I : InstructionsToHoist)
if (I->getParent() == DestBB)
// If there are two instructions in HoistPt to be hoisted in place:
// update Repl to be the first one, such that we can rename the uses
// of the second based on the first.
if (!Repl || firstInBB(I, Repl))
Repl = I;
// Keep track of whether we moved the instruction so we know whether we
// should move the MemoryAccess.
bool MoveAccess = true;
if (Repl) {
// Repl is already in HoistPt: it remains in place.
assert(allOperandsAvailable(Repl, DestBB) &&
"instruction depends on operands that are not available");
MoveAccess = false;
} else {
// When we do not find Repl in HoistPt, select the first in the list
// and move it to HoistPt.
Repl = InstructionsToHoist.front();
// We can move Repl in HoistPt only when all operands are available.
// The order in which hoistings are done may influence the availability
// of operands.
if (!allOperandsAvailable(Repl, DestBB)) {
// When HoistingGeps there is nothing more we can do to make the
// operands available: just continue.
if (HoistingGeps)
continue;
// When not HoistingGeps we need to copy the GEPs.
if (!makeGepOperandsAvailable(Repl, DestBB, InstructionsToHoist))
continue;
}
// Move the instruction at the end of HoistPt.
Instruction *Last = DestBB->getTerminator();
MD->removeInstruction(Repl);
Repl->moveBefore(Last);
DFSNumber[Repl] = DFSNumber[Last]++;
}
// Drop debug location as per debug info update guide.
Repl->dropLocation();
NR += removeAndReplace(InstructionsToHoist, Repl, DestBB, MoveAccess);
if (isa<LoadInst>(Repl))
++NL;
else if (isa<StoreInst>(Repl))
++NS;
else if (isa<CallInst>(Repl))
++NC;
else // Scalar
++NI;
}
if (MSSA && VerifyMemorySSA)
MSSA->verifyMemorySSA();
NumHoisted += NL + NS + NC + NI;
NumRemoved += NR;
NumLoadsHoisted += NL;
NumStoresHoisted += NS;
NumCallsHoisted += NC;
return {NI, NL + NC + NS};
}
std::pair<unsigned, unsigned> GVNHoist::hoistExpressions(Function &F) {
InsnInfo II;
LoadInfo LI;
StoreInfo SI;
CallInfo CI;
for (BasicBlock *BB : depth_first(&F.getEntryBlock())) {
int InstructionNb = 0;
for (Instruction &I1 : *BB) {
// If I1 cannot guarantee progress, subsequent instructions
// in BB cannot be hoisted anyways.
if (!isGuaranteedToTransferExecutionToSuccessor(&I1)) {
HoistBarrier.insert(BB);
break;
}
// Only hoist the first instructions in BB up to MaxDepthInBB. Hoisting
// deeper may increase the register pressure and compilation time.
if (MaxDepthInBB != -1 && InstructionNb++ >= MaxDepthInBB)
break;
// Do not value number terminator instructions.
if (I1.isTerminator())
break;
if (auto *Load = dyn_cast<LoadInst>(&I1))
LI.insert(Load, VN);
else if (auto *Store = dyn_cast<StoreInst>(&I1))
SI.insert(Store, VN);
else if (auto *Call = dyn_cast<CallInst>(&I1)) {
if (auto *Intr = dyn_cast<IntrinsicInst>(Call)) {
if (isa<DbgInfoIntrinsic>(Intr) ||
Intr->getIntrinsicID() == Intrinsic::assume ||
Intr->getIntrinsicID() == Intrinsic::sideeffect)
continue;
}
if (Call->mayHaveSideEffects())
break;
if (Call->isConvergent())
break;
CI.insert(Call, VN);
} else if (HoistingGeps || !isa<GetElementPtrInst>(&I1))
// Do not hoist scalars past calls that may write to memory because
// that could result in spills later. geps are handled separately.
// TODO: We can relax this for targets like AArch64 as they have more
// registers than X86.
II.insert(&I1, VN);
}
}
HoistingPointList HPL;
computeInsertionPoints(II.getVNTable(), HPL, InsKind::Scalar);
computeInsertionPoints(LI.getVNTable(), HPL, InsKind::Load);
computeInsertionPoints(SI.getVNTable(), HPL, InsKind::Store);
computeInsertionPoints(CI.getScalarVNTable(), HPL, InsKind::Scalar);
computeInsertionPoints(CI.getLoadVNTable(), HPL, InsKind::Load);
computeInsertionPoints(CI.getStoreVNTable(), HPL, InsKind::Store);
return hoist(HPL);
}
} // end namespace llvm
PreservedAnalyses GVNHoistPass::run(Function &F, FunctionAnalysisManager &AM) {
DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
PostDominatorTree &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);
AliasAnalysis &AA = AM.getResult<AAManager>(F);
MemoryDependenceResults &MD = AM.getResult<MemoryDependenceAnalysis>(F);
MemorySSA &MSSA = AM.getResult<MemorySSAAnalysis>(F).getMSSA();
GVNHoist G(&DT, &PDT, &AA, &MD, &MSSA);
if (!G.run(F))
return PreservedAnalyses::all();
PreservedAnalyses PA;
PA.preserve<DominatorTreeAnalysis>();
PA.preserve<MemorySSAAnalysis>();
return PA;
}
char GVNHoistLegacyPass::ID = 0;
INITIALIZE_PASS_BEGIN(GVNHoistLegacyPass, "gvn-hoist",
"Early GVN Hoisting of Expressions", false, false)
INITIALIZE_PASS_DEPENDENCY(MemoryDependenceWrapperPass)
INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
INITIALIZE_PASS_END(GVNHoistLegacyPass, "gvn-hoist",
"Early GVN Hoisting of Expressions", false, false)
FunctionPass *llvm::createGVNHoistPass() { return new GVNHoistLegacyPass(); }
```
|
```shell
CPU benchmark with `dd`
Find out if the system's architecture is 32 or 64 bit
Preventing a user from logging into the system
Executing scripts on system boot using `systemd`
Cancel a system shutdown
```
|
```ruby
class Openclonk < Formula
desc "Multiplayer action game"
homepage "path_to_url"
license "ISC"
revision 4
# hasn't worked for a long time, see: path_to_url
stable do
url "path_to_url"
sha256 your_sha256_hash
depends_on "glew"
on_linux do
depends_on "gtk+3"
depends_on "libx11"
end
# Fix macOS OpenGL initialization. Remove in release after v8.1.
patch do
url "path_to_url"
sha256 your_sha256_hash
end
# Fix Linux build to help find alut.h. Remove in next release.
patch do
url "path_to_url"
sha256 your_sha256_hash
end
# Fix build failure with newer GCC because of missing #include <limits>
# TODO: submit to upstream GitHub repo
patch :DATA
end
livecheck do
url "path_to_url"
regex(/href=.*?openclonk[._-]v?(\d+(?:\.\d+)+)\.t/i)
end
bottle do
sha256 cellar: :any, arm64_sonoma: your_sha256_hash
sha256 cellar: :any, arm64_ventura: your_sha256_hash
sha256 cellar: :any, arm64_monterey: your_sha256_hash
sha256 cellar: :any, arm64_big_sur: your_sha256_hash
sha256 cellar: :any, sonoma: your_sha256_hash
sha256 cellar: :any, ventura: your_sha256_hash
sha256 cellar: :any, monterey: your_sha256_hash
sha256 cellar: :any, big_sur: your_sha256_hash
sha256 cellar: :any, catalina: your_sha256_hash
sha256 x86_64_linux: your_sha256_hash
end
head do
url "path_to_url", branch: "master"
depends_on "libepoxy"
uses_from_macos "curl"
on_linux do
depends_on "miniupnpc"
depends_on "sdl2"
end
end
disable! date: "2024-01-16", because: "does not build since 2018"
depends_on "cmake" => :build
depends_on "freealut"
depends_on "freetype"
depends_on "jpeg-turbo"
depends_on "libogg"
depends_on "libpng"
depends_on "libvorbis"
depends_on "tinyxml"
uses_from_macos "zlib"
on_linux do
depends_on "pkg-config" => :build
depends_on "libxrandr"
depends_on "mesa"
depends_on "openal-soft"
end
def install
# Disable copying libraries into macOS app bundle by overwriting script
File.open(buildpath/"tools/osx_bundle_libs", "w") { |f| f.puts "#!/bin/bash" }
# Remove unneeded bundled library to avoid default fallback in build
rm_r(buildpath/"thirdparty/tinyxml")
# Modify Linux install location for openclonk binary to bin directory
inreplace "CMakeLists.txt", "install(TARGETS openclonk DESTINATION games)",
"install(TARGETS openclonk DESTINATION bin)"
# Fix compile with newer Clang
ENV.append_to_cflags "-Wno-implicit-function-declaration" if DevelopmentTools.clang_build_version >= 1403
ENV.cxx11
system "cmake", "-S", ".", "-B", "build", *std_cmake_args
system "cmake", "--build", "build"
system "cmake", "--install", "build"
return unless OS.mac?
bin.write_exec_script prefix/"openclonk.app/Contents/MacOS/openclonk"
bin.install Dir[prefix/"c4*"]
end
test do
system bin/"c4group"
end
end
__END__
diff --git a/src/gui/C4ScriptGuiWindow.cpp b/src/gui/C4ScriptGuiWindow.cpp
index 785e168..1d2c467 100755
--- a/src/gui/C4ScriptGuiWindow.cpp
+++ b/src/gui/C4ScriptGuiWindow.cpp
@@ -42,6 +42,7 @@
#include <C4Viewport.h>
#include <cmath>
+#include <limits>
// Adds some helpful logs for hunting control & menu based desyncs.
//#define MenuDebugLogF(...) DebugLogF(__VA_ARGS__)
```
|
Jean-Louis Bernard Barrault (; 8 September 1910 – 22 January 1994) was a French actor, director and mime artist who worked on both screen and stage.
Biography
Barrault was born in Le Vésinet in France in 1910. His father was 'a Burgundian pharmacist who died in the First World War.':87 He studied at the Collége Chaptal until 1930, when he began his studies at the École du Louvre.:87
Theatre
From 1931 to 1935 Barrault studied and acted at Charles Dullin's L'Atelier.:32 His first performance was a small role in Ben Jonson's Volpone. At the time, Barrault was unable to afford rent and Dullin allowed him to sleep in the theatre on Volpone's bed.:16 It was L'Atelier that he first met and studied under Étienne Decroux,:41 with whom he would create the pantomime La Vie Primitive in 1931.:87
He was a member of the Comédie-Française from 1942 to 1946, performing lead roles in Shakespeare's Hamlet and Corneille's Le Cid.:32 He and his wife, actress Madeleine Renaud, formed their own troupe, Compagnie Renaud-Barrault, in 1946 at Paris' Théâtre Marigny.:161 In 1951 he published his memoirs, Reflections on the Theatre.
He was made director of Théâtre de France in 1959, and remained in the role until 1969. In 1971 he was reappointed director of Théâtre des Nations. He retired from theatre in 1990.:87
Film
In 1935 he had his first film role in Marc Allégret's Les Beaux Jours.:87 He would go on to act in nearly 50 movies over the course of his career. One of his most famous performances was in Marcel Carné's film Les Enfants du Paradis (1945), in which he played the mime Jean-Gaspard Deburau.:161
He was the uncle of actress Marie-Christine Barrault and sometime sponsor of Peter Brook. In 1940, he married the actress Madeleine Renaud. They founded a number of theaters together and toured extensively, including in South America.
Barrault died from a heart attack in Paris on 22 January 1994, at the age of 83.:87 He is buried with his wife Renaud in the Passy Cemetery in Paris.
Filmography
References
External links
Barrault Photo Collection
1910 births
1994 deaths
Burials at Passy Cemetery
French film directors
French mimes
People from Le Vésinet
Sociétaires of the Comédie-Française
French male stage actors
French male film actors
Special Tony Award recipients
20th-century French male actors
|
Holcocera amicitiae is a moth in the family Blastobasidae which is endemic to Costa Rica.
References
Moths described in 2002
Endemic fauna of Costa Rica
amicitiae
|
```objective-c
/****************************************************************************
* MeshLab o o *
* An extendible mesh processor o o *
* _ O _ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* for more details. *
* *
****************************************************************************/
#ifndef __GL_OBJECT_H__
#define __GL_OBJECT_H__
class GLObject
{
public:
GLObject(void)
{
this->objectID = 0;
}
virtual ~GLObject(void)
{
}
GLuint ObjectID(void) const
{
return this->objectID;
}
bool ValidObject(void) const
{
return (this->objectID != 0);
}
virtual void Gen(void) = 0;
virtual void Del(void) = 0;
protected:
GLuint objectID;
};
class Bindable
{
public:
Bindable(void)
{
this->bound = false;
}
void Bind(void)
{
this->bound = true;
this->DoBind();
}
void Unbind(void)
{
this->DoUnbind();
this->bound = false;
}
bool IsBound(void) const
{
return this->bound;
}
protected:
bool bound;
virtual void DoBind(void) = 0;
virtual void DoUnbind(void) = 0;
};
#endif //__GL_OBJECT_H__
```
|
```shell
#!/bin/sh
# This script is based on a git-svn tree.
BOOST=$1
mkdir -p src/include/firebird/impl
bcp --boost=$BOOST --namespace=FirebirdImpl preprocessor/seq src/include/firebird/impl
find src/include/firebird/impl/boost -type f -exec sed -i 's/BOOST_/FB_BOOST_/g' {} \;
find src/include/firebird/impl/boost -type f -exec sed -i 's/<boost\//<firebird\/impl\/boost\//g' {} \;
g++ -ggdb -Isrc/include/gen -Isrc/include -E src/include/firebird/Message.h | sed -n -e 's/.*"\(.*impl.*\)".*/\1/p' | sort -u > gen/boost
for line in `cat gen/boost`; do git add $line; done
git add src/include/firebird/impl/boost/preprocessor/control
git add src/include/firebird/impl/boost/preprocessor/detail
git add src/include/firebird/impl/boost/preprocessor/repetition/detail
rm gen/boost
echo Now run this:
echo git commit src/include/firebird/impl/boost
echo rm -rf src/include/firebird/impl/boost
echo git checkout -- src/include/firebird
```
|
```python
#!/usr/bin/env python2
"""
tuple_return_value.py
"""
from __future__ import print_function
import os
from mycpp import mylib
from mycpp.mylib import log
from typing import Tuple, List
def f(x):
# type: (int) -> Tuple[int, str]
i = x + 42
s = 'foo bar'
return i, s[1:]
def run_tests():
# type: () -> None
i, s = f(0)
log("i = %d", i)
log("s = %s", s)
items = [] # type: List[Tuple[int, str]]
items.append((43, 'bar'))
log('length = %d', len(items))
mytuple = (44, 'spam')
myint, mystr = mytuple
def run_benchmarks():
# type: () -> None
for i in xrange(1000000):
j, s = f(i)
if j == 100000:
print(str(i))
mylib.MaybeCollect()
if __name__ == '__main__':
if os.getenv('BENCHMARK'):
log('Benchmarking...')
run_benchmarks()
else:
run_tests()
```
|
```yaml
storage:
type: object
object:
type: azblob
```
|
Vicki Mowat is a Canadian politician, who was elected to the Legislative Assembly of Saskatchewan in a by-election on September 7, 2017. She represents the electoral district of Saskatoon Fairview as a member of the Saskatchewan New Democratic Party.
A former executive assistant to the associate dean of Aboriginal affairs at the University of Saskatchewan, she was also the party's candidate in the same district in the 2016 provincial election.
Vicki Mowat is a retired member of the Canadian Armed Forces, after serving in the Cadet Instructors Cadre – the branch of the Canadian Armed Forces that administers and trains the Cadet Program of Canada. Vicki Mowat served for several years at the Vernon Cadet Training Center, achieving the rank of Major.
Electoral record
References
Living people
Saskatchewan New Democratic Party MLAs
Women MLAs in Saskatchewan
Politicians from Saskatoon
21st-century Canadian politicians
21st-century Canadian women politicians
Year of birth missing (living people)
|
```xml
export const COMPODOC_CONSTANTS = {
navTabDefinitions: [
{
id: 'info',
href: '#info',
'data-link': 'info',
label: 'Info',
depTypes: ['all']
},
{
id: 'readme',
href: '#readme',
'data-link': 'readme',
label: 'README',
depTypes: ['all']
},
{
id: 'source',
href: '#source',
'data-link': 'source',
label: 'Source',
depTypes: ['all']
},
{
id: 'templateData',
href: '#templateData',
'data-link': 'template',
label: 'Template',
depTypes: ['component']
},
{
id: 'styleData',
href: '#styleData',
'data-link': 'style',
label: 'Styles',
depTypes: ['component']
},
{
id: 'tree',
href: '#tree',
'data-link': 'dom-tree',
label: 'DOM Tree',
depTypes: ['component']
},
{
id: 'example',
href: '#example',
'data-link': 'example',
label: 'Examples',
depTypes: ['component', 'directive', 'injectable', 'pipe']
}
]
};
/**
* Max length for the string of a file during Lunr search engine indexing.
* Prevent stack size exceeded
*/
export const MAX_SIZE_FILE_SEARCH_INDEX = 50000;
/**
* Max length for the string of a file during cheerio parsing.
* Prevent stack size exceeded
*/
export const MAX_SIZE_FILE_CHEERIO_PARSING = 400000000;
```
|
Ordonnac (; ) is a commune in the Gironde department in Nouvelle-Aquitaine, southwestern France.
Population
See also
Communes of the Gironde department
References
Communes of Gironde
|
Zhufan (, local accent:zhuf, or Juf) also called West Zhufan or Xizhufan (), is an administrative village governed by Shilianghe Town () of Donghai County, in the north of Jiangsu Province, China.
The village lies to the west of Ganyu of Lianyungang. It borders Shandong Province to the northeast and Ganyu to the northwest. Tangzi River is in the east, and Zhufan River is in the southwest.
Until the 1980s, Zhufan was located on the Tangzi River's western bank, earning it the nickname Hexi (River West) among the locals. Due to flood damage in the 1980s, a new village was built to the northeast of the old village, and the village is now located on the Tangzi River's eastern bank. It now includes Wang Zhufan, Wang Banlu, and Yuan Banlu.
Geography
Landscape and rivers
The village is located in the low flat plain between Zhufan and Tangzi rivers. The river serves as the boundary between the villages.
The confluence of the two rivers forms Tangzi River. The larger one flows southward from the eastern upland area of Yushan Town in Linshu County, Shandong Province. The small one flows southwest from Ganyu County in Jiangsu Province's western hilly countries. The two rivers enter Zhufan to the south of G327 and meet to the west of the Public Tomb Area and to the east of Zhufan's Bamboo Yard. Then it flows southward, then eastward for 570 meters at Yandan Jing (Duck Egg Well), then southward again. Finally, it comes together in Reservoir Shilianghe, west of Mengjialing Village.
River Zhufan has two sources as well. The small source, River Zhufan, flows southward from Mount Cangma in Linshu Town, Linshu County, and converges in Reservoir Jiaolong. River Mutuan is a large source formed in the western hilly countries of Yushan Town in Linshu County. The two sources meet between Lietuan Village and Zhangtuan Village, flow southeastward, and meet at Reservoir Shilianghe in Dongwozi Village's east.
Before the construction of Reservoir Shilianghe in 1958, River Tangzi was also historically known as River Dongjiawan after Dongjiawan Village, located west of Mengjialing Village. In the past, River Tangzi and River Zhufan combined near Sanjiaowang Village to form River Dasha, a larger river. After then, River Shiliang, created from Mount Maling, merged with River Dasha. In Linhongkou, the River Dasha flowed southeast and entered the Yellow Sea. The New River Shoo was created after 1949 from the riverbeds of the River Shilianghe and the River Dasha.
Climate
Zhufan has a monsoon-influenced climate with generous summer precipitation, cold, dry winters, and hot, humid in summers. Under the Köppen climate classification, is in the transition from the humid subtropical zone (Cwa) to the humid continental zone (Dwa), though favouring the former. More than half of the annual precipitation of falls in July and August alone, and the frost-free period is above 200 days.
Economy
Zhufan's economy is heavily dependent on crop farming and construction. Crops cover wheat, paddy, peanut and corn, and soybean. The other crops such as Red adzuki beans, and mung beans are planted occasionally on some small fields. Usually, women and old men are the main laborers in farming. Most of the younger men are construction workers.
There is some primitive industry in wood and meat processing and cement products. They only provide a few industrial products.
Zhufan has a country fair for the adjoining areas. The villagers buy and sell food, clothes, necessities, hardware, and farming tools, on some fixed days in every month as per the Lunar Calendar. There are also some small markets in the village.
Demography
Population
According to China's 2010 census, the village had a population of 3200. All the villagers are Han Chinese.
Wang () is the most popular family name in the village. It covers two families: Sanhuaitang () and Yeyutang () .
The family of Sanghuaitang declares that they came from Danglu, a little village near Huaguoshan of Lianyungang. they do not know when they arrived at this village in paper or oral legend. But they arrived at this village much earlier than the family of Yeyutang.
The family of Yeyutang came from Dengzhou of Shandong Province during Chongzhen (BC1628~BC1644) (year's name of Emperor Sizong Zhu Youjian) in the Ming dynasty. The ancestor who came to the village was a fisherman. The family regard Xinzhuang, a village near Qingkou of Ganyu County, as their home place.
However, the latest Genealogy research shows that the two families are descended from a man named Wang Ying, who lived in the Later period of Southern Song. Wang Ying's elder son became the ancestor of Yeyutang Family, and the junior was the ancestor of Sanhuaitang Family.
Other families' names cover Zhu (), Xu (), Xiang (), Li (), Yuan (), Liu (), Lǚ (), Zhang (), etc., and about 10% of families use them. But there is no Wang's family in Yuan Banlu.
Religion
Chinese folk beliefs are practiced widely. The villagers worship ancestors, ghost and kinds of gods. But there are no fixed religious places and rites. The Villagers can finish the rites by themselves in the ancestors' tombs or the courtyards.
Some people also practice Christianity. But most Christians are old men and women. They only take part in religious gatherings, listen to the preach and sing religious songs. They cannot distinguish Christ from other gods worshiped by most of the Chinese people usually. They believe that Christ may have greater power than common Chinese gods. Some villagers regard Christianity as a cult because Christians are usually more passionate about religious affairs than other topics.
Dialect
The dialect of Zhufan is kind of Central Plain Mandarin. However, there are many differences from other Central Plain Mandarin, because it lies in the most eastern part of the dialect. Being adjacent to Jialiao Man Mandarin Zone, it is affected by Jiaoliao Mandarin, and keeps some characters of pronunciation and many words of Jialiao Mandarin.
The system of consonants and vowels of local dialect is much more like Ganyu Dialect, a dialect more like Jiaoliao Mandarin than Central Plain Mandarin. But the tones are more similar to Central Plain Dialect than Ganyu Dialect. The consonant of /w/ and vowel of /u/ do not exist, and are replaced by /v/. There is also no initial letter R in Standard Mandarin. For example, the Re (热,hot) and Ye (叶,leaf) are homonyms in the local dialect. Some consonant clusters exist in the local accent, for example, kl and pl.
Comparatively, the local people speak usually a little quicker.
Administrative Managing System and Politics
There are three natural villages in Zhufan since the early 1950s. The three natural villages are: Wang Zhufan (), Yuan Banlu () and Wang Banlu () . But the natural villages are not village managing units. The basic managing unit of the village is the villager group, according to Organic Law of Village Committees. Zhufan is divided into 7 villager groups. Wang Zhufan covers 1st – 5th villager group; Wang Banlu is the 6th villager group and Yuan Banlu 7th villager group.
In the Chinese mainland, all the administrative villages serve as a fundamental organizational unit for its rural population, not as part of a system of government. As a bureaucratic entity, the director of the village committee is a corporate representative and is traditionally called the Village Chief by the villagers. The election of the director of the village committee is held every three years. The influence over the election is usually from the township government, large clans, the rich, and even the gangsters. The latest election was held in 2011.
The Chinese Communist Party is the sole legal party. Its secretary of the village branch is the supreme leader de facto of the village. The percentage of communist party members is less than 1% of all villagers. And most of them are only statistical members of the Party.
History
The name Zhufan () was first mentioned by a Genealogy Book of Yeyutang Wangshi, written in the 1850s. But the official documents shortly after, the name of the village was written as “诸樊” or “朱樊”.
There are no records that record when the village was founded. But according to the legend, the earliest residents were all members of the Fan family (), and the village was also called Fanjia Zhuang (the village of Fan family). Hundreds of years later, the family of Zhu () gradually replaced the Fan and became the main residents. Thus, the village's name changed to Zhufan Zhuang (the village of Fan and Zhu families. Years later, the Wang () family came to this village and became the main residents in the early Ming dynasty (1368–1644). The name of the village changed to Wangzhufan () and is fixed.
There is a historic site of ancient Zhuqi in Gucheng Village of Ganyu County, about 1.5 km northeastward from Zhufan. Zhuqi is a small vassal state, whose founder and founding time are all not clear. During early Dong Zhou, it was conquered by State of Lu and became one of Lu's border city. From the Qin dynasty to the Tang dynasty, zhuqi had been the county site before it was combined with Huairen County (i.e. Ganyu County)
In the Ming dynasty and Qing dynasty, it became the border of Yichow Fu of Shandong province and was governed by Lanshan County.
Lanshan County changed its name to Linyi County during the Republic of China. Jufan is a village under Linshu Town of Linyi County. Linshu Town became the Fifth District of Linyi County in 1934.
During the Second Sino-Japanese War, the Chinese Communist Party came here and domain rural areas. Zhufan became the center of areas controlled by the Communist Party and the seat of division headquarters of the 18th Army 115 Division. The Communist Party divided the eastern part of Linyi County, the western part of Ganyu County, and the northeastern part of Tancheng County to find a new county named Linshu. Zhufan became a village in this new county.
After the Communist Party obtained control over China's Mainland, most areas were taken apart and adjusted. Zhufan was divided into five small villages: Wang Zhufan, Xu Zhufan, Yao Zhufan, Wang Banlu, and Yuan Banlu. Every village has its own basic branch of the Communist Party ruling the village.
In 1962, the Reservoir Shilianghe was completed and stored water. Thus, Zhufan became submerged, and villagers had to move northward. But the new houses are very bad because of the corruption of the Communist officials. Many houses collapsed when rainstorms came in summer. So the villagers had to move back to the old site to build new houses.
In April 1971, Zhufan was put under Jiangsu Province. The villagers were not willing to live in Ganyu County, so the Zhufan became a village of Donghai County. In 1978, Zhufan was a village in Nanchen Town.
During the early 1980s, the villagers built their new home in the farthest northeastern part of the village near G327.
In February 2013, Nanchen Town and Shilianghe Town were combined into a new Shilianghe Town.
References
Lianyungang
Villages in China
|
```objective-c
/*
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef AUDIO_MOCK_VOE_CHANNEL_PROXY_H_
#define AUDIO_MOCK_VOE_CHANNEL_PROXY_H_
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "api/crypto/frame_decryptor_interface.h"
#include "api/test/mock_frame_encryptor.h"
#include "audio/channel_receive.h"
#include "audio/channel_send.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "test/gmock.h"
namespace webrtc {
namespace test {
class MockChannelReceive : public voe::ChannelReceiveInterface {
public:
MOCK_METHOD(void, SetNACKStatus, (bool enable, int max_packets), (override));
MOCK_METHOD(void,
RegisterReceiverCongestionControlObjects,
(PacketRouter*),
(override));
MOCK_METHOD(void, ResetReceiverCongestionControlObjects, (), (override));
MOCK_METHOD(CallReceiveStatistics, GetRTCPStatistics, (), (const, override));
MOCK_METHOD(NetworkStatistics,
GetNetworkStatistics,
(bool),
(const, override));
MOCK_METHOD(AudioDecodingCallStats,
GetDecodingCallStatistics,
(),
(const, override));
MOCK_METHOD(int, GetSpeechOutputLevelFullRange, (), (const, override));
MOCK_METHOD(double, GetTotalOutputEnergy, (), (const, override));
MOCK_METHOD(double, GetTotalOutputDuration, (), (const, override));
MOCK_METHOD(uint32_t, GetDelayEstimate, (), (const, override));
MOCK_METHOD(void, SetSink, (AudioSinkInterface*), (override));
MOCK_METHOD(void, OnRtpPacket, (const RtpPacketReceived& packet), (override));
MOCK_METHOD(void,
ReceivedRTCPPacket,
(const uint8_t*, size_t length),
(override));
MOCK_METHOD(void, SetChannelOutputVolumeScaling, (float scaling), (override));
MOCK_METHOD(AudioMixer::Source::AudioFrameInfo,
GetAudioFrameWithInfo,
(int sample_rate_hz, AudioFrame*),
(override));
MOCK_METHOD(int, PreferredSampleRate, (), (const, override));
MOCK_METHOD(void, SetSourceTracker, (SourceTracker*), (override));
MOCK_METHOD(void,
SetAssociatedSendChannel,
(const voe::ChannelSendInterface*),
(override));
MOCK_METHOD(bool,
GetPlayoutRtpTimestamp,
(uint32_t*, int64_t*),
(const, override));
MOCK_METHOD(void,
SetEstimatedPlayoutNtpTimestampMs,
(int64_t ntp_timestamp_ms, int64_t time_ms),
(override));
MOCK_METHOD(absl::optional<int64_t>,
GetCurrentEstimatedPlayoutNtpTimestampMs,
(int64_t now_ms),
(const, override));
MOCK_METHOD(absl::optional<Syncable::Info>,
GetSyncInfo,
(),
(const, override));
MOCK_METHOD(bool, SetMinimumPlayoutDelay, (int delay_ms), (override));
MOCK_METHOD(bool, SetBaseMinimumPlayoutDelayMs, (int delay_ms), (override));
MOCK_METHOD(int, GetBaseMinimumPlayoutDelayMs, (), (const, override));
MOCK_METHOD((absl::optional<std::pair<int, SdpAudioFormat>>),
GetReceiveCodec,
(),
(const, override));
MOCK_METHOD(void,
SetReceiveCodecs,
((const std::map<int, SdpAudioFormat>& codecs)),
(override));
MOCK_METHOD(void, StartPlayout, (), (override));
MOCK_METHOD(void, StopPlayout, (), (override));
MOCK_METHOD(
void,
SetDepacketizerToDecoderFrameTransformer,
(rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer),
(override));
MOCK_METHOD(
void,
SetFrameDecryptor,
(rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor),
(override));
MOCK_METHOD(void, OnLocalSsrcChange, (uint32_t local_ssrc), (override));
MOCK_METHOD(uint32_t, GetLocalSsrc, (), (const, override));
};
class MockChannelSend : public voe::ChannelSendInterface {
public:
MOCK_METHOD(void,
SetEncoder,
(int payload_type, std::unique_ptr<AudioEncoder> encoder),
(override));
MOCK_METHOD(
void,
ModifyEncoder,
(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier),
(override));
MOCK_METHOD(void,
CallEncoder,
(rtc::FunctionView<void(AudioEncoder*)> modifier),
(override));
MOCK_METHOD(void, SetRTCP_CNAME, (absl::string_view c_name), (override));
MOCK_METHOD(void,
SetSendAudioLevelIndicationStatus,
(bool enable, int id),
(override));
MOCK_METHOD(void,
RegisterSenderCongestionControlObjects,
(RtpTransportControllerSendInterface*, RtcpBandwidthObserver*),
(override));
MOCK_METHOD(void, ResetSenderCongestionControlObjects, (), (override));
MOCK_METHOD(CallSendStatistics, GetRTCPStatistics, (), (const, override));
MOCK_METHOD(std::vector<ReportBlock>,
GetRemoteRTCPReportBlocks,
(),
(const, override));
MOCK_METHOD(ANAStats, GetANAStatistics, (), (const, override));
MOCK_METHOD(void,
RegisterCngPayloadType,
(int payload_type, int payload_frequency),
(override));
MOCK_METHOD(void,
SetSendTelephoneEventPayloadType,
(int payload_type, int payload_frequency),
(override));
MOCK_METHOD(bool,
SendTelephoneEventOutband,
(int event, int duration_ms),
(override));
MOCK_METHOD(void,
OnBitrateAllocation,
(BitrateAllocationUpdate update),
(override));
MOCK_METHOD(void, SetInputMute, (bool muted), (override));
MOCK_METHOD(void,
ReceivedRTCPPacket,
(const uint8_t*, size_t length),
(override));
MOCK_METHOD(void,
ProcessAndEncodeAudio,
(std::unique_ptr<AudioFrame>),
(override));
MOCK_METHOD(RtpRtcpInterface*, GetRtpRtcp, (), (const, override));
MOCK_METHOD(int, GetBitrate, (), (const, override));
MOCK_METHOD(int64_t, GetRTT, (), (const, override));
MOCK_METHOD(void, StartSend, (), (override));
MOCK_METHOD(void, StopSend, (), (override));
MOCK_METHOD(void,
SetFrameEncryptor,
(rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor),
(override));
MOCK_METHOD(
void,
SetEncoderToPacketizerFrameTransformer,
(rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer),
(override));
};
} // namespace test
} // namespace webrtc
#endif // AUDIO_MOCK_VOE_CHANNEL_PROXY_H_
```
|
Khunga may refer to:
Khunga, Baglung
Khunga, Panchthar
|
Lembah Pantai may refer to:
Lembah Pantai
Lembah Pantai (federal constituency), represented in the Dewan Rakyat
|
Juliet Winters Carpenter (born 1948) is an American translator of modern Japanese literature. Born in the American Midwest, she studied Japanese literature at the University of Michigan and the Inter-University Center for Japanese Language Studies in Tokyo. After completing her graduate studies in 1973, she returned to Japan in 1975, where she became involved in translation efforts and teaching.
Carpenter is a devotee of traditional Japanese music and is a licensed instructor of the koto and shamisen. She is professor emeritus at Doshisha Women's College of Liberal Arts in Kyoto and has been involved in the Japanese Literature Publishing Project(JLPP), a government-supported project translating and publishing Japanese books overseas.
Carpenter retired to Whidbey Island in Washington State with her husband Bruce, professor emeritus of Tezukayama University. They have three children: Matthew Edwin Carpenter, Graham, and Mark.
Carpenter's translation of Abe Kobo's novel Secret Rendezvous (Mikkai in Japanese) won the 1980 Japan-U.S. Friendship Commission Prize for the Translation of Japanese Literature. Her translation of Minae Mizumura's novel Honkaku Shosetsu, "A True Novel," won that same award for 2014-2015 and earned numerous other awards including the 2014 Lewis Galantière Award of the American Translators Association.
Once Upon a Time in Japan, a book of folk tales which she co-translated with Roger Pulvers, received the 2015 Gelett Burgess Children's Book Award for Best Multicultural Book.
Carpenter won the 2021-2022 Lindsey and Masao Miyoshi Translation Prize for a lifetime achievement as a translator of modern Japanese literature, with particular reference to her recent translation of Mizumura Minae’s An I-Novel (Columbia University Press, 2021)
An I-Novel, translated by Carpenter, won the 2019-20 William F. Sibley Memorial Subvention Award for Japanese Translation.
Her translation of The Great Passage by Miura Shion, an audio Book read by Brian Nishii, won the 2017 Golden Earphones Award.
Selected works
Translations
Other works
Carpenter is also the author of the book Seeing Kyoto.
References
Televised nostalgia in Japan: Those were the days
A translator's work from Abe to Zen/Professor continues wide-ranging literary pursuits with epic novel by Ryotaro Shiba
The Asian Bookshelf by Donald Richie: Blood, sweat and tears of Zen
Strange Moors: 'A True Novel,' by Minae Mizumura
1948 births
Living people
American speculative fiction translators
Japanese–English translators
American expatriates in Japan
Koto players
University of Michigan College of Literature, Science, and the Arts alumni
Japanese literature academics
American women writers
20th-century American translators
21st-century American translators
20th-century American women
21st-century American women
|
```xml
import { MathAngledBrackets, MathCurlyBrackets, MathRoundBrackets, MathSquareBrackets } from "./brackets";
import { MathFraction } from "./fraction";
import { MathFunction } from "./function";
import { MathRun } from "./math-run";
import { MathSum, MathIntegral } from "./n-ary";
import { MathRadical } from "./radical";
import { MathSubScript, MathSubSuperScript, MathSuperScript } from "./script";
export type MathComponent =
| MathRun
| MathFraction
| MathSum
| MathIntegral
| MathSuperScript
| MathSubScript
| MathSubSuperScript
| MathRadical
| MathFunction
| MathRoundBrackets
| MathCurlyBrackets
| MathAngledBrackets
| MathSquareBrackets;
// Needed because of: path_to_url
/**
* @ignore
*/
export const WORKAROUND4 = "";
```
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package io.material.catalog.elevation;
import io.material.catalog.R;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
import androidx.annotation.ArrayRes;
import androidx.annotation.LayoutRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.google.android.material.card.MaterialCardView;
import com.google.android.material.internal.ViewUtils;
import io.material.catalog.feature.DemoFragment;
import io.material.catalog.feature.DemoUtils;
import java.util.List;
/** A fragment that displays the main Elevation demo for the Catalog app. */
public class ElevationMainDemoFragment extends DemoFragment {
protected int currentElevationLevel = 0;
protected int elevationInDp;
private int[] elevationLevelValues;
@Override
public View onCreateDemoView(
LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
View view = layoutInflater.inflate(getDemoContent(), viewGroup, false /* attachToRoot */);
elevationLevelValues = getResources().getIntArray(getElevationLevelValues());
Button increaseButton = view.findViewById(R.id.increase_elevation);
Button decreaseButton = view.findViewById(R.id.decrease_elevation);
increaseButton.setOnClickListener(
button -> updateCardsElevationLevel(view, currentElevationLevel + 1));
decreaseButton.setOnClickListener(
button -> updateCardsElevationLevel(view, currentElevationLevel - 1));
updateCardsElevationLevel(view, currentElevationLevel);
return view;
}
@LayoutRes
private int getDemoContent() {
return R.layout.cat_elevation_fragment;
}
@SuppressWarnings("RestrictTo") // It's safe to use restricted MDC code in MDC Catalog.
private void updateCardsElevationLevel(View view, int newElevationLevel) {
List<MaterialCardView> elevationCards =
DemoUtils.findViewsWithType(view, MaterialCardView.class);
if (newElevationLevel >= 0 && newElevationLevel <= getMaxElevationValue()) {
setElevationLevel(newElevationLevel);
for (MaterialCardView elevationCard : elevationCards) {
elevationCard.setCardElevation(ViewUtils.dpToPx(view.getContext(), elevationInDp));
}
setElevationLevelTextView(view, getElevationLevelText());
}
}
private void setElevationLevel(int newElevationLevel) {
currentElevationLevel = newElevationLevel;
elevationInDp = elevationLevelValues[currentElevationLevel];
}
private static void setElevationLevelTextView(View view, @NonNull String levelText) {
TextView levelTextView = view.findViewById(R.id.current_elevation_level_label);
levelTextView.setText(levelText);
}
protected String getElevationLevelText() {
return getResources().getString(R.string.cat_elevation_fragment_level, elevationInDp);
}
@ArrayRes
protected int getElevationLevelValues() {
return R.array.cat_elevation_level_values;
}
private int getMaxElevationValue() {
return elevationLevelValues.length - 1;
}
}
```
|
Muhammad Asif Rana (born 20 April 1985) is a Pakistani former field hockey player. He competed in the men's tournament at the 2008 Summer Olympics.
References
External links
1985 births
Living people
Pakistani male field hockey players
Olympic field hockey players for Pakistan
Field hockey players at the 2008 Summer Olympics
Place of birth missing (living people)
|
The Calumet Harbor lighthouse is a three-story, open-air lighthouse and observation tower located in Calumet Harbor, in the town of Calumet, Wisconsin, approximately one mile west of Pipe, Wisconsin. It is located on the eastern shore of Lake Winnebago, inside the Columbia Park, a Fond du Lac County park. The structure is a steel skeletal tower with two flashing white strobe lights located on top.
Notes
Further reading
Havighurst, Walter (1943) The Long Ships Passing: The Story of the Great Lakes, Macmillan Publishers.
Oleszewski, Wes, Great Lakes Lighthouses, American and Canadian: A Comprehensive Directory/Guide to Great Lakes Lighthouses, (Gwinn, Michigan: Avery Color Studios, Inc., 1998) .
Wright, Larry and Wright, Patricia, Great Lakes Lighthouses Encyclopedia Hardback (Erin: Boston Mills Press, 2006) .
External links
Lighthouses in Wisconsin
Buildings and structures in Fond du Lac County, Wisconsin
|
```turing
Some macros treat ':' as an argument delimiter but others do not. A consequence
of this is macro arguments which intentionally include a ':' character may look
like a sequence of multiple arguments but are treated as a single argument by
macros that don't split their argument on ':'. This tests that we maintain this
behaviour as we change the way that macros are implemented.
This test installs a binary whose name contains a ':' character and then checks
that we can look up the binary with the `bin` macro which does not split its
arguments on ':'.
$ cat > dune-project <<EOF
> (lang dune 3.0)
> (package (name foo))
> EOF
$ cat > foo.sh <<EOF
> #!/usr/bin/env sh
> echo foo
> EOF
$ chmod +x foo.sh
$ cat >dune <<EOF
> ; Use an install stanza to rename the script to "foo:bar"
> (install
> (section bin)
> (files (foo.sh as foo:bar)))
>
> ; Generate out.txt by running the script now named "foo:bar"
> (rule
> (target out.txt)
> (action
> (with-stdout-to %{target}
> (run %{bin:foo:bar}))))
> EOF
$ dune build out.txt
$ cat _build/default/out.txt
foo
```
|
HNLMS Pieter de Bitter was a of the Royal Netherlands Navy that served in World War II.
Service history
Pieter de Bitter was scuttled at Surabaya on 6 March 1942.
Jan van Amstel-class minesweepers
Ships built in Rotterdam
1936 ships
World War II minesweepers of the Netherlands
World War II shipwrecks in the Pacific Ocean
Maritime incidents in March 1942
|
Hilmi Volkan Demir is a Turkish scientist, best known for his works on white light generation.
Biography
Hilmi Volkan Demir was born on July 4, 1976, in Kars, Turkey. He received his B.Sc. degree in electrical and electronics engineering from Bilkent University, Ankara, Turkey, in 1998, and his M.S. and Ph.D. degrees in electrical engineering from Stanford University, California, in 2000 and 2004, respectively. He received his Docent title (Assoc. Prof.) in Optics and Photonics from the Turkish Council of Higher Education in 2007. Since September 2004, he has been working as a faculty member at Bilkent University, where he holds joint appointments at the Department of Physics and at the Department of Electrical and Electronics Engineering. He is the Associate Director of Nanotechnology Research Center. He also serves as a faculty member of the Advanced Research Laboratory and the Institute of Materials Science and Nanotechnology.
In August 2009, he was assigned as Nanyang Associate Professor jointly at the School of Electrical and Electronic Engineering (Microelectronics Div.) and the School of Physical and Mathematical Sciences (Physics and Applied Physics Division) at the Nanyang Technological University, Singapore.
Research
At Bilkent, he is the principal investigator of the Devices and Sensors Research Group. His current research interests and projects include the development and demonstration of innovative hybrid nanophotonic devices, nanocrystal, metal nanoparticle and nanowire embedded nanodevices, high-performance RF and Optoelectronics sensors, III-nitride optoelectronic devices, white LEDs, and photovoltaic devices. He has published more than 100 peer-reviewed research articles in major scientific journals and conferences, presented more than 100 invited lectures, seminars, and conference talks around the world, and has more than 10 patents at various stages of the process. He has an overall h-index of 34 and i10-index of 100, as per Google Scholar.
Awards
Dr. Demir is one of the winners of 2007 ESF-EURYI. He is also the recipient of 2008 Prof. M. N. Parlar Young Scientist Award, 2006 TUBA-GEBIP (Turkish National Academy of Sciences Distinguished Young Scientist Award), and 2005 European Union Marie Curie Fellowship Award. He is a member of the professional societies such as the Optical Society, IEEE Photonics Society, IEEE, and SPIE and the alumni associations of Stanford University, Bilkent University, and Ankara Science High School.
References
External links
Personal Page
List of Publications
Devices and Sensors Research Group at Bilkent University
LUMINOUS! Centre of Excellence for Semiconductor Lighting and Displays at Nanyang Technological University
Turkish physicists
Living people
1976 births
People from Kağızman
Bilkent University alumni
Turkish electronics engineers
Electrical engineering academics
Academic staff of Bilkent University
Stanford University School of Engineering alumni
Optical engineers
Optical physicists
Academic staff of Nanyang Technological University
Turkish nanotechnologists
|
List
See also
2008 in Romania
List of 2008 box office number-one films in Romania
Lists of 2008 films by country or language
2009
2008 in Romanian cinema
|
```objective-c
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_EVENTS_OZONE_EVDEV_EVENTS_OZONE_EVDEV_EXPORT_H_
#define UI_EVENTS_OZONE_EVDEV_EVENTS_OZONE_EVDEV_EXPORT_H_
#if defined(COMPONENT_BUILD)
#if defined(WIN32)
#if defined(EVENTS_OZONE_EVDEV_IMPLEMENTATION)
#define EVENTS_OZONE_EVDEV_EXPORT __declspec(dllexport)
#else
#define EVENTS_OZONE_EVDEV_EXPORT __declspec(dllimport)
#endif // defined(EVENTS_OZONE_EVDEV_IMPLEMENTATION)
#else // defined(WIN32)
#if defined(EVENTS_OZONE_EVDEV_IMPLEMENTATION)
#define EVENTS_OZONE_EVDEV_EXPORT __attribute__((visibility("default")))
#else
#define EVENTS_OZONE_EVDEV_EXPORT
#endif
#endif
#else // defined(COMPONENT_BUILD)
#define EVENTS_OZONE_EVDEV_EXPORT
#endif
#endif // UI_EVENTS_OZONE_EVDEV_EVENTS_OZONE_EVDEV_EXPORT_H_
```
|
```ruby
# frozen_string_literal: true
module Decidim
module Initiatives
# Exposes Initiatives versions so users can see how an Initiative
# has been updated through time.
class VersionsController < Decidim::Initiatives::ApplicationController
include ParticipatorySpaceContext
helper InitiativeHelper
include NeedsInitiative
include Decidim::ResourceVersionsConcern
def versioned_resource
current_initiative
end
private
def current_participatory_space_manifest
@current_participatory_space_manifest ||= Decidim.find_participatory_space_manifest(:initiatives)
end
end
end
end
```
|
Bosnia and Herzegovina competed at the 2014 Winter Olympics in Sochi, Russia, from 7 to 23 February 2014. The team consists of five athletes in three sports. The team marched in the opening ceremony wearing clothes that paid homage to the 30th anniversary of the 1984 Winter Olympics held in Sarajevo.
The selection of alpine skier Žana Novaković as flagbearer resulted in controversy as another skier, Igor Laikert, had better results. There were suggestions that this had to due with the ethnic divide in the country with Laikert coming from the Muslim-Croat community.
Alpine skiing
According to the quota allocation released on 20 January 2014, Bosnia and Herzegovina had three athletes in qualification position.
Biathlon
Bosnia and Herzegovina received a reallocation quota spot in biathlon. Tanja Karišik also competed in cross-country skiing.
Cross-country skiing
According to the quota allocation released on 20 January 2014, Bosnia and Herzegovina had two athletes in qualification position.
Distance
Sprint
References
External links
Nations at the 2014 Winter Olympics
2014 Winter Olympics
Olympics
|
Space Cadet is the fourth extended play (EP) by Filipino-born English singer-songwriter Beabadoobee. The EP was released on 14 October 2019 by independent record label Dirty Hit, and was supported by the singles "She Plays Bass" and "I Wish I Was Stephen Malkmus". All five tracks were executively produced by English musicians Pete Robertson (of the Vaccines) and Joseph Rodgers. The EP was also written entirely by Beabadoobee and features additional guitar from Matthew Healy (of the 1975) on the title track.
Background and release
Beabadoobee released "She Plays Bass" as the lead single on 21 August, before releasing the second single "I Wish I Was Stephen Malkmus" on 19 September. The latter is in reference to Stephen Malkmus of the band Pavement. Beabadoobee confessed to Nylon in early October that she hadn't formally announced the record but noted that "people know about it. I kind of say it here and there on a live show and then I guess like for [interviews], but I never properly said the name Space Cadet." Originally scheduled for release on 18 October 2019, Space Cadet arrived earlier on 14 October. It succeeds the EPs Lice (2018), Patched Up (2018) and Loveworm (2019). On the concept of the record, Erica Russel of Teen Vogue wrote, "aptly-titled Space Cadet finds the artist leaning heavily into the frustration of being misunderstood and the awkward uncertainty of inching closer towards adulthood. Over an emotive soundbed of fuzzy indie-rock, melancholic grunge, and breezy pop-rock, Bea reassures listeners that it’s okay not to fit in."
Composition
The EP is musically performed in the genre of indie rock and indie pop. Erica Russel of Teen Vogue also wrote that the record features "an emotive soundbed of fuzzy indie-rock, melancholic grunge, and breezy pop-rock". All five tracks on Space Cadet were executively produced by Pete Robertson (former drummer of the Vaccines) and Joseph Rodgers. The title track also features additional guitar by labelmate Matthew Healy of the band the 1975 whom Beabadoobee would later support on their Music for Cars Tour.
Critical reception
Space Cadet was met with critical acclaim upon release. Thomas Smith of NME wrote noted that Space Cadet "builds on Bea’s astute songwriting and is a bold revolution for another bright young artist showing off Gen Z’s attitude to take something tried-and-tested and give it a new lease of life." He continued to note that "judging by this effort, she’s poised to become a hero in her own right." Stephen Ackroyd of Dork wrote that "from the word go, this is a fuller, more focused take on the template - scuzzy guitars and slacker pop perfection." Nicole DeMarco of i-D wrote that the EP contains "some of Bea’s most expansive work yet" and noted that the EP indicates her growth "from [a] bedroom artist to indie rock wunderkind." Harper Beattie of Atwood Magazine praised Space Cadet, writing that it "has artfully managed to offer a cohesive showcase of [her] range as a rising artist while incorporating the familiar outer space motif." Cady Siregar of The Line of Best Fit wrote that with the record, Beabadoobee "wears her heart on her sleeve, and she doesn’t care who sees it." Ian Gormely of Exclaim! noted that her ability to "spin emotional stakes out of such basic subject matter as her bass-playing bestie and love for '90s alt-rock" as well as "the sheer speed of her progression as a songwriter, suggest big things to come."
Track listing
Charts
References
2019 EPs
Beabadoobee EPs
Dirty Hit albums
|
Cedar Lake is a town in Hanover and Center townships, Lake County, Indiana, United States. It is near the Illinois state line. Its population was 11,560 at the 2010 census. The town is notable for its location on Cedar Lake, the Lake of the Red Cedars museum.
History
Cedar Lake was settled by pioneers in the mid-19th century and was originally named West Point; the name “Cedar Lake” belonged to a nearby town that is now called Creston, Indiana. In 1839, the town that was then called West Point competed with the settlements of Liverpool and Lake Court House (later called Crown Point) to be the county seat of Lake County, but lost out to Liverpool. By 1870, the Cedar Lake Post Office was established, giving the area a new name. After the Monon Railroad came to the lake's western shore in 1882, many new residents flocked to the area along with tourists who saw the lake as a resort destination. From the late 19th century to the early 20th century, Cedar Lake was a popular place for Chicagoans looking for a retreat from the city. The lake had over 50 hotels at the time and several pavilions and ballrooms that brought many well-known bands to entertain the visitors.
The Lassen Hotel and Monon Park Dancing Pavilion are listed in the National Register of Historic Places.
Geography
According to the 2010 census, Cedar Lake has a total area of , of which (or 85.54%) is land and (or 14.46%) is water. The lake, which is the largest natural lake in northwest Indiana, appears to have formed from glacial meltwaters. There is an abundance of hills around the lake, which are evidence of the Valparaiso Moraine running through the area.
The 781 acre lake is naturally fed by small streams, storm runoff, and a natural spring. The lake has a median depth of 8.8 feet. Its deepest depth at 16 feet located in the middle basin. The lack of clarity in the water is due to the low refresh rate of the water and the shallow depths combined with the size of the lake. The lake bed is composed mostly of a dirt and sand mixture, clay, and rocks.
Demographics
2010 census
As of the census of 2010, there were 11,560 people, 4,193 households, and 3,002 families living in the town. The population density was . There were 4,692 housing units at an average density of . The racial makeup of the town was 94.9% White, 0.5% African American, 0.3% Native American, 0.4% Asian, 2.4% from other races, and 1.7% from two or more races. Hispanic or Latino of any race were 6.5% of the population.
There were 4,193 households, of which 39.1% had children under the age of 18 living with them, 53.9% were married couples living together, 11.7% had a female householder with no husband present, 6.0% had a male householder with no wife present, and 28.4% were non-families. 22.1% of all households were made up of individuals, and 5.9% had someone living alone who was 65 years of age or older. The average household size was 2.75 and the average family size was 3.23.
The median age in the town was 34.9 years. 26.6% of residents were under the age of 18; 8.7% were between the ages of 18 and 24; 29.3% were from 25 to 44; 26.6% were from 45 to 64; and 8.6% were 65 years of age or older. The gender makeup of the town was 50.7% male and 49.3% female.
2000 census
As of the census of 2000, there were 9,279 people, 3,394 households, and 2,450 families living in the town. The population density was . There were 3,681 housing units at an average density of . The racial makeup of the town was 97.40% White, 0.09% African American, 0.24% Native American, 0.20% Asian, 0.88% from other races, and 1.19% from two or more races. Hispanic or Latino of any race were 3.50% of the population.
There were 3,394 households, out of which 37.9% had children under the age of 18 living with them, 57.9% were married couples living together, 10.2% had a female householder with no husband present, and 27.8% were non-families. 22.5% of all households were made up of individuals, and 7.0% had someone living alone who was 65 years of age or older. The average household size was 2.73 and the average family size was 3.23.
In the town, the population was spread out, with 28.5% under the age of 18, 9.2% from 18 to 24, 32.9% from 25 to 44, 20.6% from 45 to 64, and 8.8% who were 65 years of age or older. The median age was 34 years. For every 100 females, there were 104.0 males. For every 100 females age 18 and over, there were 102.3 males.
The median income for a household in the town was $43,987, and the median income for a family was $50,431. Males had a median income of $41,825 versus $24,861 for females. The per capita income for the town was $17,825. About 4.0% of families and 6.6% of the population were below the poverty line, including 6.7% of those under age 18 and 7.4% of those age 65 or over.
Education
Lake County Public Library operates the Cedar Lake Library at 10010 West 133rd Avenue.
Cedar Lake is home to the Hanover Community School Corporation and the Crown Point Community School Corporation. The Hanover School corporation operates two elementary schools: Lincoln and Jane Ball, one middle school: Hanover Central Middle School, and one high school: Hanover Central High School. The Crown Point school corporation operates one elementary school in Cedar Lake: MacArthur. Those in the Crown Point school system attend middle school and high school in Crown Point at Taft Middle School and Crown Point High School (CPHS).
References
Kenneth J. Schoon, Calumet Beginnings, 2003, p. 20-23
External links
Town of Cedar Lake, Indiana website
Structures offer slices of Cedar Lake's past - article by Scott Bocock, member of the Cedar Lake Historical Association
Towns in Lake County, Indiana
Northwest Indiana
Towns in Indiana
Populated places established in 1967
1967 establishments in Indiana
|
```shell
`Firewall` as a service
Quick port test with `netcat`
Check `iptables` firewall status
Setting up password-free authentication
Use `tcpdump` to listen to network interface traffic
```
|
```javascript
console.log("Test output from debuggee");
/**
* Sample React Native App
* path_to_url
*
* @format
* @flow strict-local
*/
import React from 'react';
import type {Node} from 'react';
import { SafeAreaView, ScrollView, StatusBar, StyleSheet, Text, useColorScheme, View } from 'react-native';
import { Colors, DebugInstructions, Header, LearnMoreLinks, ReloadInstructions } from 'react-native/Libraries/NewAppScreen';
const Section = ({children, title}): Node => {
const isDarkMode = useColorScheme() === 'dark';
return (
<View style={styles.sectionContainer}>
<Text
style={[
styles.sectionTitle,
{
color: isDarkMode ? Colors.white : Colors.black,
},
]}>
{title}
</Text>
<Text
style={[
styles.sectionDescription,
{
color: isDarkMode ? Colors.light : Colors.dark,
},
]}>
{children}
</Text>
</View>
);
};
const App: () => Node = () => {
const isDarkMode = useColorScheme() === 'dark';
const backgroundStyle = {
backgroundColor: isDarkMode ? Colors.darker : Colors.lighter,
};
return (
<SafeAreaView style={backgroundStyle}>
<StatusBar barStyle={isDarkMode ? 'light-content' : 'dark-content'} />
<ScrollView
contentInsetAdjustmentBehavior="automatic"
style={backgroundStyle}>
<Header />
<View
style={{
backgroundColor: isDarkMode ? Colors.black : Colors.white,
}}>
<Section title="Step One">
Edit <Text style={styles.highlight}>App.js</Text> to change this
screen and then come back to see your edits.
</Section>
<Section title="See Your Changes">
<ReloadInstructions />
</Section>
<Section title="Debug">
<DebugInstructions />
</Section>
<Section title="Learn More">
Read the docs to discover what to do next:
</Section>
<LearnMoreLinks />
</View>
</ScrollView>
</SafeAreaView>
);
};
const styles = StyleSheet.create({
sectionContainer: {
marginTop: 32,
paddingHorizontal: 24,
},
sectionTitle: {
fontSize: 24,
fontWeight: '600',
},
sectionDescription: {
marginTop: 8,
fontSize: 18,
fontWeight: '400',
},
highlight: {
fontWeight: '700',
},
});
export default App;
```
|
Point Douglas is a ghost town in section 8 of Denmark Township, Washington County, Minnesota, United States located at the convergence of the St. Croix River and the Mississippi River. It is located across the St Croix River from Prescott, Wisconsin.
History
Point Douglas was platted on August 18, 1849 and named in honor of Stephen A. Douglas. The post office, with Levi Hurtsell as first postmaster, was the first in the County, and was transferred from Wisconsin Territory when Minnesota Territory was created. It was discontinued in 1903. In 1856, the site was a trade center and had a mill, several warehouses, and a lime kiln. The town also had a station of the Chicago, Milwaukee, St. Paul and Pacific Railroad. Today, all that remains of Point Douglas is a small development along U.S. Route 10
References
External links
Former populated places in Minnesota
Former populated places in Washington County, Minnesota
Minnesota populated places on the Mississippi River
|
```xml
/*
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
// TypeScript Version: 4.1
/**
* Returns the expected value of a binomial distribution.
*
* ## Notes
*
* - If provided a number of trials `n` which is not a nonnegative integer, the function returns `NaN`.
* - If `p < 0` or `p > 1`, the function returns `NaN`.
*
* @param n - number of trials
* @param p - success probability
* @returns expected value
*
* @example
* var v = mean( 100, 0.1 );
* // returns 10.0
*
* @example
* var v = mean( 20, 0.5 );
* // returns 10.0
*
* @example
* var v = mean( 10.3, 0.5 );
* // returns NaN
*
* @example
* var v = mean( 20, 1.1 );
* // returns NaN
*
* @example
* var v = mean( 20, NaN );
* // returns NaN
*/
declare function mean( n: number, p: number ): number;
// EXPORTS //
export = mean;
```
|
```smalltalk
using System;
using System.Collections.Generic;
using Android.Content;
using Android.Runtime;
namespace Android.App {
public partial class ProgressDialog {
public static ProgressDialog? Show (Context context, Java.Lang.ICharSequence title, Java.Lang.ICharSequence message, bool indeterminate, bool cancelable, EventHandler cancelHandler)
{
return Show (context, title, message, indeterminate, cancelable, new IDialogInterfaceOnCancelListenerImplementor () { Handler = cancelHandler });
}
public static ProgressDialog? Show (Context context, string title, string message, bool indeterminate, bool cancelable, EventHandler cancelHandler)
{
return Show (context, title, message, indeterminate, cancelable, new IDialogInterfaceOnCancelListenerImplementor () { Handler = cancelHandler });
}
}
}
```
|
```objective-c
/* config.h. Generated from config.h.in by configure. */
/* config.h.in. Generated from configure.ac by autoheader. */
/* Command name to run C preprocessor */
#define CPP_PROG "cc -E"
/* */
/* #undef ENABLE_NLS */
/* Define to 1 if you have the `abort' function. */
#define HAVE_ABORT 1
/* */
/* #undef HAVE_CATGETS */
/* Define to 1 if you have the Mac OS X function CFLocaleCopyCurrent in the
CoreFoundation framework. */
/* #undef HAVE_CFLOCALECOPYCURRENT */
/* Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in
the CoreFoundation framework. */
/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */
/* Define if the GNU dcgettext() function is already present or preinstalled.
*/
#define HAVE_DCGETTEXT 1
/* Define to 1 if you have the <direct.h> header file. */
/* #undef HAVE_DIRECT_H */
/* Define to 1 if you have the `ftruncate' function. */
#define HAVE_FTRUNCATE 1
/* Define to 1 if you have the `getcwd' function. */
#define HAVE_GETCWD 1
/* */
#define HAVE_GETTEXT 1
/* Define to 1 if you have the GNU C Library */
#define HAVE_GNU_C_LIBRARY 1
/* Define if you have the iconv() function and it works. */
/* #undef HAVE_ICONV */
/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1
/* */
/* #undef HAVE_LC_MESSAGES */
/* Define to 1 if you have the <libgen.h> header file. */
#define HAVE_LIBGEN_H 1
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
/* Define to 1 if you have the `mergesort' function. */
/* #undef HAVE_MERGESORT */
/* Define to 1 if you have the `popen' function. */
#define HAVE_POPEN 1
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* */
/* #undef HAVE_STPCPY */
/* Define to 1 if you have the `strcasecmp' function. */
#define HAVE_STRCASECMP 1
/* Define to 1 if you have the `strcmpi' function. */
/* #undef HAVE_STRCMPI */
/* Define to 1 if you have the `stricmp' function. */
/* #undef HAVE_STRICMP */
/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the `strncasecmp' function. */
#define HAVE_STRNCASECMP 1
/* Define to 1 if you have the `strsep' function. */
#define HAVE_STRSEP 1
/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if you have the `toascii' function. */
#define HAVE_TOASCII 1
/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
/* Define to 1 if you have the `vsnprintf' function. */
#define HAVE_VSNPRINTF 1
/* Define to 1 if you have the `_stricmp' function. */
/* #undef HAVE__STRICMP */
/* Name of package */
#define PACKAGE "yasm"
/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT "bug-yasm@tortall.net"
/* Define to the full name of this package. */
#define PACKAGE_NAME "yasm"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "yasm 1.3.0"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "yasm"
/* Define to the home page for this package. */
#define PACKAGE_URL ""
/* Define to the version of this package. */
#define PACKAGE_VERSION "1.3.0"
/* Define to 1 if the C compiler supports function prototypes. */
#define PROTOTYPES 1
/* The size of `char', as computed by sizeof. */
/* #undef SIZEOF_CHAR */
/* The size of `int', as computed by sizeof. */
/* #undef SIZEOF_INT */
/* The size of `long', as computed by sizeof. */
/* #undef SIZEOF_LONG */
/* The size of `short', as computed by sizeof. */
/* #undef SIZEOF_SHORT */
/* The size of `void*', as computed by sizeof. */
/* #undef SIZEOF_VOIDP */
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Version number of package */
#define VERSION "1.3.0"
/* Define if using the dmalloc debugging malloc package */
/* #undef WITH_DMALLOC */
/* Define like PROTOTYPES; this can be used by system headers. */
#define __PROTOTYPES 1
/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */
/* Define to `__inline__' or `__inline' if that's what the C compiler
calls it, or to nothing if 'inline' is not supported under any name. */
#ifndef __cplusplus
/* #undef inline */
#endif
/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */
```
|
True Stories: Selected Non-Fiction is a collection of short non-fiction works by Australian writer Helen Garner first published in 1996 by Text Publishing. The short works in the collection start with Garner's immediate notes as a school teacher to her journalist accounts of visiting a morgue and a maternity ward in a hospital. It won the 1997 Nita Kibble Literary Award.
References
1996 non-fiction books
1996 short story collections
Australian short story collections
|
Born of the Night was the second album of the band Midnight Syndicate, released in 1998.
Track listing
"Premonition" – 2:31
"Darkness Descends" – 2:01
"Born of the Night" – 3:14
"Lost Souls" – 1:17
"Dark Tower" – 3:16
"The Apparition" – 1:07
"Gargoyles" – 2:49
"Lurking Fear" – 1:02
"Shadows" – 3:05
"Whispers" – 0:28
"Solemn Reflections" – 2:48
"Haunted Nursery" – 2:48
"Woe" – 1:35
"Masque of Sorrow" – 2:08
"Requiem" – 2:58
"Dungeon" – 0:58
"Something Wicked" – 3:03
"Vampire's Kiss" – 2:21
"Nightstalker" – 2:43
"Midnight" – 1:26
"Forbidden Crypts" – 3:52
References
External links
Album Info on Midnight Syndicate Band website
1998 albums
Midnight Syndicate albums
|
The 2010–11 Danish Cup was the 57th season of the Danish football cup competition. For the third year, the sponsor of the competition was Ekstra Bladet, a daily newspaper, who signed a 3-year contract with the Danish Football Association (DBU) in 2008, making the official name Ekstra Bladet Cup 2010–11.
The competition opened on 9 August 2010 with the First Round and concluded on 22 May 2011 with the Final at the Parken Stadium.
First round
In this round entered 96 teams. There were 48 matches in the First Round, taking place between 9 and 17 August 2010.
Second round
The clubs who placed 5–10 in the 2009–10 Superliga – AaB, Midtjylland, Nordsjælland, Silkeborg, SønderjyskE and Randers – as well as the top two clubs from the 2009–10 First Division – Horsens and Lyngby – received a bye into the second round. These matches were played from 24 to 26 August 2010.
Third round
The top four teams from the 2008–09 Superliga – Copenhagen, OB, Brøndby and Esbjerg – received a bye into the third round. These matches took place on 22, 23 and 29 September 2010.
|}
Fourth round
The sixteen winners in Round 3 took part in Round 4. The draw occurred on 25 September 2010. The matches took place between 26 and 28 October 2010.
|}
Quarter-finals
The eight winners from the previous round competed in this round. These matches took place between 9 and 11 November 2010.
Semi-finals
The four winners from the Quarter Finals will compete in this round. This round will be played as a two-legged tie. The legs will be played on 27 April and 4 May 2011.
|}
First leg
Second leg
Final
The final was played on 22 May 2011.
References
External links
Official results at Danish FA official website
2010-11
2010–11 domestic association football cups
Cup
|
Subwoolfer is a British-Norwegian pop duo formed in 2021. The two members perform in black suits with white shirts with distinctive yellow stylized wolf-head masks and yellow gloves and ties and go by the pseudonyms Keith and Jim. Their identities were publicly revealed on 4 February 2023 as Ben Adams and Gaute Ormåsen, during the final of . After winning , they represented Norway in the Eurovision Song Contest 2022 with their debut song "Give That Wolf a Banana". The name of the duo is a portmanteau of the words subwoofer and wolf.
History
On 10 January 2022, the Norwegian public broadcaster, NRK, revealed that Subwoolfer would compete in , the Norwegian national selection for the Eurovision Song Contest 2022. Having been selected as an automatically qualified finalist, they were scheduled to showcase their entry "Give That Wolf a Banana" in the third heat of the competition on 29 January. However, their performance was postponed to the fourth heat, due to a positive COVID-19 test. They performed "Give That Wolf a Banana" again in the final on 19 February, and went on to win the competition with 368,106 votes from the public. With their victory, they were selected to represent Norway in the Eurovision Song Contest 2022, which was held in Turin, Italy.
On 11 February 2022, Subwoolfer released a Valentine's Day version of "Give That Wolf a Banana", titled "Give That Wolf a Romantic Banana". As of 17 June 2022, "Give That Wolf a Banana" has been streamed more than 20.4 million times on Spotify, with its Valentine edition having been streamed over 918 thousand times.
As Keith and Jim dress in yellow wolf-like masks during performances, the duo's real identities remained undisclosed throughout 2022. Their desired anonymity led to some speculation on social media regarding their identities. At the time, Keith and Jim's speculated identities included the Ylvis brothers, Gaute Ormåsen, Ben Adams and Erik & Kriss. A fictional origin story about the duo states that they are the "most successful band in our galaxy," and began their career "4.5 billion years ago on the Moon."
On 10 May 2022, NRK filmed DJ Astronaut taking off his helmet, with his identity speculated to be Tix, the Norwegian entrant at the Eurovision Song Contest 2021. This was later denied by the Norwegian head of delegation, Stig Karlsen, and Tix himself. Tix was later revealed to be the Norwegian jury spokesperson for the Eurovision 2022 final.
On 23 May 2022, Subwoolfer announced that "new music [would be] out soon" in a music video on YouTube for their parody of "Grace Kelly" by Mika, titled "Space Kelly" which had gained over 1 million views as of 17 June 2022. On 1 July 2022, Subwoolfer released "Melocoton (The Donka Donk Song)", their first song since the Eurovision Song Contest. It was accompanied by a music video.
On 21 October 2022, Subwoolfer released a new single, "Howling", which features guest vocals from Luna Ferrari, the "sister" of Keith and Jim. The music video for Howling was released on 21 October 2022. In December 2022, Subwoolfer made a short guest appearance on The Big Fat Quiz of the Year after a question on their Eurovision entry was featured in the music round.
On 4 February 2023, Subwoolfer appeared in the final of , where they took their masks off, and it was confirmed that Keith and Jim were Adams and Ormåsen respectively.
On 3 March 2023, the documentary "Worst Kept Secret: The Subwoolfer Documentary" was released. In the documentary was revealed that DJ Astronaut was played by Ormåsen himself on stage while a stand-in danced in the front row as Jim, excluding the idea of an actual third musician or singer in the group.
Discography
Singles
References
Norwegian pop music groups
Eurovision Song Contest entrants for Norway
Eurovision Song Contest entrants of 2022
Melodi Grand Prix contestants
Melodi Grand Prix winners
Masked musicians
Norwegian musical duos
Universal Music Group artists
Musical groups established in 2022
|
```objective-c
//
// MWPhoto.h
// MWPhotoBrowser
//
// Created by Michael Waterfall on 17/10/2010.
//
#import <Foundation/Foundation.h>
#import <Photos/Photos.h>
#import "MWPhotoProtocol.h"
// This class models a photo/image and it's caption
// If you want to handle photos, caching, decompression
// yourself then you can simply ensure your custom data model
// conforms to MWPhotoProtocol
@interface MWPhoto : NSObject <MWPhoto>
@property (nonatomic, strong) NSString *caption;
@property (nonatomic, strong) NSURL *videoURL;
@property (nonatomic) BOOL emptyImage;
@property (nonatomic) BOOL isVideo;
+ (MWPhoto *)photoWithImage:(UIImage *)image;
+ (MWPhoto *)photoWithURL:(NSURL *)url;
+ (MWPhoto *)photoWithAsset:(PHAsset *)asset targetSize:(CGSize)targetSize;
+ (MWPhoto *)videoWithURL:(NSURL *)url; // Initialise video with no poster image
- (id)init;
- (id)initWithImage:(UIImage *)image;
- (id)initWithURL:(NSURL *)url;
- (id)initWithAsset:(PHAsset *)asset targetSize:(CGSize)targetSize;
- (id)initWithVideoURL:(NSURL *)url;
@end
```
|
```yaml
name: aliases_rename
description: A program that replaces a resource with a new name and alias.
runtime: go
```
|
```ruby
# This code is released under a tri EPL/GPL/LGPL license. You can use it,
# redistribute it and/or modify it under the terms of the:
#
$LOAD_PATH << File.join(File.dirname(__FILE__))
$LOAD_PATH << File.join(File.dirname(__FILE__), 'psd.rb', 'lib')
$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'chunky_png', 'chunky_png', 'lib')
require 'mock-logger'
require 'chunky_png/color'
require 'psd/color'
require 'psd/util'
require 'psd/image_modes/greyscale'
WIDTH = 1000
HEIGHT = 1000
CHANNEL_DATA = [128] * WIDTH * HEIGHT * 2
class MockImage
include PSD::ImageMode::Greyscale
public :combine_greyscale_channel
def initialize
@num_pixels = WIDTH * HEIGHT
@channel_length = @num_pixels
@channel_data = CHANNEL_DATA
@pixel_data = []
end
def channels
2
end
def pixel_step
2
end
def pixel_data
@pixel_data
end
def reset
@pixel_data.clear
end
end
image = MockImage.new
benchmark do
image.combine_greyscale_channel
image.reset
end
```
|
The 14th Writers Guild of America Awards honored the best film writers and television writers of 1961. Winners were announced in 1962.
Winners & Nominees
Film
Winners are listed first highlighted in boldface.
Television
Special Awards
References
External links
WGA.org
1961
W
Writers Guild of America Awards
Writers Guild of America Awards
Writers Guild of America Awards
|
The Altonaer Theater (before Altona's annexation to Hamburg, the Altonaer Stadttheater, i.e., Altona City Theater) is a theater in Hamburg, Germany. The private theater adapts literary works for the stagbe, from classics and international bestsellers to young German literature and more. Past productions include Anna Karenina, Steppenwolf, Measuring the World, and The Hundred-Year-Old Man Who Climbed Out the Window and Disappeared. It presents its own productions, guest performances, and special events. Axel Schneider has been the theater manager since 1995.
History
In 1783, the theater opened on Palmaille "for the leisure of the citizens." It proved an ideal venue for character comedy and drama. After the war, it reopened on Königstraße in 1876. There, more and more contemporary works were staged, which was unusual at the time. In 1943, the building with the beautiful auditorium fell victim to the bombs of World War II.
Since 1954, the auditorium in the former Haus der Jugend (vocational school) on Museumstraße has been the new venue. The complex was built in 1928–30 to designs by Urban Planning Senator Gustav Oelsner. The Neues Bauen-style reinforced concrete structure stands in deliberate contrast with the Altona City Hall and the Altona Museum.
External links
Altonaer Theater
Theatres in Hamburg
Buildings and structures in Altona, Hamburg
|
Warm Nights may refer to:
Warm Nights (album), a 1996 album by Robert Forster
Warm Nights (film), a 1961 Egyptian film
See also
Warm Nights on a Slow Moving Train, a 1988 Australian film
"Warm Night", a song by The Concretes
|
The BGMUT (Blood Group antigen gene MUTation) Database documents allelic variations in the genes encoding for human blood group systems. It was set up in 1999 through an initiative of the Human Genome Variation Society (HGVS). Since 2006, it has been a part of the dbRBC (database Red Blood Cells) resource of NCBI at the NIH. In addition to being a repository of the genetic variations of the blood group antigen-encoding genes, the database also provides information on the blood group systems, the genes that encode them, the serological phenotypes associated with the alleles of the genes, etc. Information on genetic variations in some non-human orthologous genes is also provided.
References
External links
Biological databases
|
```c++
//===-- examples/ParallelJIT/ParallelJIT.cpp - Exercise threaded-safe JIT -===//
//
// See path_to_url for license information.
//
//===your_sha256_hash------===//
//
// Parallel JIT
//
// This test program creates two LLVM functions then calls them from three
// separate threads. It requires the pthreads library.
// The three threads are created and then block waiting on a condition variable.
// Once all threads are blocked on the conditional variable, the main thread
// wakes them up. This complicated work is performed so that all three threads
// call into the JIT at the same time (or the best possible approximation of the
// same time). This test had assertion errors until I got the locking right.
//
//===your_sha256_hash------===//
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/ExecutionEngine/MCJIT.h"
#include "llvm/IR/Argument.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/TargetSelect.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <memory>
#include <vector>
#include <pthread.h>
using namespace llvm;
static Function* createAdd1(Module *M) {
LLVMContext &Context = M->getContext();
// Create the add1 function entry and insert this entry into module M. The
// function will have a return type of "int" and take an argument of "int".
Function *Add1F =
Function::Create(FunctionType::get(Type::getInt32Ty(Context),
{Type::getInt32Ty(Context)}, false),
Function::ExternalLinkage, "add1", M);
// Add a basic block to the function. As before, it automatically inserts
// because of the last argument.
BasicBlock *BB = BasicBlock::Create(Context, "EntryBlock", Add1F);
// Get pointers to the constant `1'.
Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
// Get pointers to the integer argument of the add1 function...
assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg
Argument *ArgX = &*Add1F->arg_begin(); // Get the arg
ArgX->setName("AnArg"); // Give it a nice symbolic name for fun.
// Create the add instruction, inserting it into the end of BB.
Instruction *Add = BinaryOperator::CreateAdd(One, ArgX, "addresult", BB);
// Create the return instruction and add it to the basic block
ReturnInst::Create(Context, Add, BB);
// Now, function add1 is ready.
return Add1F;
}
static Function *CreateFibFunction(Module *M) {
LLVMContext &Context = M->getContext();
// Create the fib function and insert it into module M. This function is said
// to return an int and take an int parameter.
FunctionType *FibFTy = FunctionType::get(Type::getInt32Ty(Context),
{Type::getInt32Ty(Context)}, false);
Function *FibF =
Function::Create(FibFTy, Function::ExternalLinkage, "fib", M);
// Add a basic block to the function.
BasicBlock *BB = BasicBlock::Create(Context, "EntryBlock", FibF);
// Get pointers to the constants.
Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2);
// Get pointer to the integer argument of the add1 function...
Argument *ArgX = &*FibF->arg_begin(); // Get the arg.
ArgX->setName("AnArg"); // Give it a nice symbolic name for fun.
// Create the true_block.
BasicBlock *RetBB = BasicBlock::Create(Context, "return", FibF);
// Create an exit block.
BasicBlock *RecurseBB = BasicBlock::Create(Context, "recurse", FibF);
// Create the "if (arg < 2) goto exitbb"
Value *CondInst = new ICmpInst(*BB, ICmpInst::ICMP_SLE, ArgX, Two, "cond");
BranchInst::Create(RetBB, RecurseBB, CondInst, BB);
// Create: ret int 1
ReturnInst::Create(Context, One, RetBB);
// create fib(x-1)
Value *Sub = BinaryOperator::CreateSub(ArgX, One, "arg", RecurseBB);
Value *CallFibX1 = CallInst::Create(FibF, Sub, "fibx1", RecurseBB);
// create fib(x-2)
Sub = BinaryOperator::CreateSub(ArgX, Two, "arg", RecurseBB);
Value *CallFibX2 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB);
// fib(x-1)+fib(x-2)
Value *Sum =
BinaryOperator::CreateAdd(CallFibX1, CallFibX2, "addresult", RecurseBB);
// Create the return instruction and add it to the basic block
ReturnInst::Create(Context, Sum, RecurseBB);
return FibF;
}
struct threadParams {
ExecutionEngine* EE;
Function* F;
int value;
};
// We block the subthreads just before they begin to execute:
// we want all of them to call into the JIT at the same time,
// to verify that the locking is working correctly.
class WaitForThreads
{
public:
WaitForThreads()
{
n = 0;
waitFor = 0;
int result = pthread_cond_init( &condition, nullptr );
(void)result;
assert( result == 0 );
result = pthread_mutex_init( &mutex, nullptr );
assert( result == 0 );
}
~WaitForThreads()
{
int result = pthread_cond_destroy( &condition );
(void)result;
assert( result == 0 );
result = pthread_mutex_destroy( &mutex );
assert( result == 0 );
}
// All threads will stop here until another thread calls releaseThreads
void block()
{
int result = pthread_mutex_lock( &mutex );
(void)result;
assert( result == 0 );
n ++;
//~ std::cout << "block() n " << n << " waitFor " << waitFor << std::endl;
assert( waitFor == 0 || n <= waitFor );
if ( waitFor > 0 && n == waitFor )
{
// There are enough threads blocked that we can release all of them
std::cout << "Unblocking threads from block()" << std::endl;
unblockThreads();
}
else
{
// We just need to wait until someone unblocks us
result = pthread_cond_wait( &condition, &mutex );
assert( result == 0 );
}
// unlock the mutex before returning
result = pthread_mutex_unlock( &mutex );
assert( result == 0 );
}
// If there are num or more threads blocked, it will signal them all
// Otherwise, this thread blocks until there are enough OTHER threads
// blocked
void releaseThreads( size_t num )
{
int result = pthread_mutex_lock( &mutex );
(void)result;
assert( result == 0 );
if ( n >= num ) {
std::cout << "Unblocking threads from releaseThreads()" << std::endl;
unblockThreads();
}
else
{
waitFor = num;
pthread_cond_wait( &condition, &mutex );
}
// unlock the mutex before returning
result = pthread_mutex_unlock( &mutex );
assert( result == 0 );
}
private:
void unblockThreads()
{
// Reset the counters to zero: this way, if any new threads
// enter while threads are exiting, they will block instead
// of triggering a new release of threads
n = 0;
// Reset waitFor to zero: this way, if waitFor threads enter
// while threads are exiting, they will block instead of
// triggering a new release of threads
waitFor = 0;
int result = pthread_cond_broadcast( &condition );
(void)result;
assert(result == 0);
}
size_t n;
size_t waitFor;
pthread_cond_t condition;
pthread_mutex_t mutex;
};
static WaitForThreads synchronize;
void* callFunc( void* param )
{
struct threadParams* p = (struct threadParams*) param;
// Call the `foo' function with no arguments:
std::vector<GenericValue> Args(1);
Args[0].IntVal = APInt(32, p->value);
synchronize.block(); // wait until other threads are at this point
GenericValue gv = p->EE->runFunction(p->F, Args);
return (void*)(intptr_t)gv.IntVal.getZExtValue();
}
int main() {
InitializeNativeTarget();
LLVMInitializeNativeAsmPrinter();
LLVMContext Context;
// Create some module to put our function into it.
std::unique_ptr<Module> Owner = std::make_unique<Module>("test", Context);
Module *M = Owner.get();
Function* add1F = createAdd1( M );
Function* fibF = CreateFibFunction( M );
// Now we create the JIT.
ExecutionEngine* EE = EngineBuilder(std::move(Owner)).create();
//~ std::cout << "We just constructed this LLVM module:\n\n" << *M;
//~ std::cout << "\n\nRunning foo: " << std::flush;
// Create one thread for add1 and two threads for fib
struct threadParams add1 = { EE, add1F, 1000 };
struct threadParams fib1 = { EE, fibF, 39 };
struct threadParams fib2 = { EE, fibF, 42 };
pthread_t add1Thread;
int result = pthread_create( &add1Thread, nullptr, callFunc, &add1 );
if ( result != 0 ) {
std::cerr << "Could not create thread" << std::endl;
return 1;
}
pthread_t fibThread1;
result = pthread_create( &fibThread1, nullptr, callFunc, &fib1 );
if ( result != 0 ) {
std::cerr << "Could not create thread" << std::endl;
return 1;
}
pthread_t fibThread2;
result = pthread_create( &fibThread2, nullptr, callFunc, &fib2 );
if ( result != 0 ) {
std::cerr << "Could not create thread" << std::endl;
return 1;
}
synchronize.releaseThreads(3); // wait until other threads are at this point
void* returnValue;
result = pthread_join( add1Thread, &returnValue );
if ( result != 0 ) {
std::cerr << "Could not join thread" << std::endl;
return 1;
}
std::cout << "Add1 returned " << intptr_t(returnValue) << std::endl;
result = pthread_join( fibThread1, &returnValue );
if ( result != 0 ) {
std::cerr << "Could not join thread" << std::endl;
return 1;
}
std::cout << "Fib1 returned " << intptr_t(returnValue) << std::endl;
result = pthread_join( fibThread2, &returnValue );
if ( result != 0 ) {
std::cerr << "Could not join thread" << std::endl;
return 1;
}
std::cout << "Fib2 returned " << intptr_t(returnValue) << std::endl;
return 0;
}
```
|
```shell
# This file is sourced in to the CI environment
# in .gitlab-ci.yml
#
# Sets the error behaviour options for shell throughout the CI environment
#
set -o errexit # Exit if command failed.
set -o pipefail # Exit if pipe failed.
# We can use the appropriate CI variable for debugging
DEBUG_SHELL=${DEBUG_SHELL:-"0"}
[ "${DEBUG_SHELL}" = "1" ] && set -x
[ -z $CI_COMMIT_REF_NAME ] && echo "This internal script should only be run by a Gitlab CI runner." && exit 1
# Compiler flags to thoroughly check the IDF code in some CI jobs
# (Depends on default options '-Wno-error=XXX' used in the IDF build system)
if [ "$IDF_TOOLCHAIN" != "clang" ]; then
PEDANTIC_FLAGS="-Werror -Werror=deprecated-declarations -Werror=unused-variable -Werror=unused-but-set-variable -Werror=unused-function"
export PEDANTIC_CFLAGS="${PEDANTIC_FLAGS} -Wstrict-prototypes"
else
export PEDANTIC_CFLAGS="-Werror"
fi
export PEDANTIC_CXXFLAGS="${PEDANTIC_FLAGS}"
# ccache related settings.
# IDF_CCACHE_ENABLE may be enabled at job level (see build.yml). However it is possible to override it
# globally via CI_CCACHE_DISABLE, in case there are any ccache related issues.
if [ "$CI_CCACHE_DISABLE" = 1 ]; then
export IDF_CCACHE_ENABLE=0
echo "INFO: ccache disabled globally using CI_CCACHE_DISABLE=0"
fi
# path_to_url#_configuring_ccache
# Set ccache base directory to the project checkout path, to cancel out differences between runners
export CCACHE_BASEDIR="${CI_PROJECT_DIR}"
# host mapping volume to share ccache fbetween runner concurrent jobs
export CCACHE_SLOPPINESS="time_macros"
# CCACHE_RECACHE Used when invalidating the current cache.
# could be enabled by MR label "ccache:recache"
if [ -n "${CI_MERGE_REQUEST_LABELS}" ] && echo "${CI_MERGE_REQUEST_LABELS}" | grep -q "ccache::recache"; then
export CCACHE_RECACHE="1"
echo "INFO: ccache recache enabled"
fi
# 'CI_CCACHE_DISABLE_NOHASHDIR' variable can be used at project level to revert to hash_dir=true, in
# case we start seeing failures due to false cache hits.
if [ "${CI_CCACHE_DISABLE_NOHASHDIR}" != "1" ]; then
export CCACHE_NOHASHDIR="1"
echo "INFO: ccache CCACHE_NOHASHDIR option is enabled"
fi
# If 'REDIS_CACHE' variable is set at runner (or project) level, use that as secondary ccache storage.
# This can be disabled at project level using 'CI_CCACHE_DISABLE_SECONDARY', in case of issues.
if [ "${CI_CCACHE_DISABLE_SECONDARY}" != "1" ] && [ -n "${REDIS_CACHE}" ]; then
export CCACHE_SECONDARY_STORAGE="redis://${REDIS_CACHE}"
echo "INFO: Using CCACHE_SECONDARY_STORAGE=${CCACHE_SECONDARY_STORAGE}"
fi
export LDGEN_CHECK_MAPPING="1"
```
|
```objective-c
/*
* Compatibility header
*
*
* This program is free software; you can redistribute it and/or modify
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
* for all of the code used other than OpenSSL. * If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. * If you
* do not wish to do so, delete this exception statement from your
* version. * If you delete this exception statement from all source
* files in the program, then also delete it here.
*/
#ifndef _AIRCRACK_NG_BYTEORDER_H_
#define _AIRCRACK_NG_BYTEORDER_H_
#define ___my_swab16(x) \
((u_int16_t)( \
(((u_int16_t)(x) & (u_int16_t)0x00ffU) << 8) | \
(((u_int16_t)(x) & (u_int16_t)0xff00U) >> 8) ))
#define ___my_swab32(x) \
((u_int32_t)( \
(((u_int32_t)(x) & (u_int32_t)0x000000ffUL) << 24) | \
(((u_int32_t)(x) & (u_int32_t)0x0000ff00UL) << 8) | \
(((u_int32_t)(x) & (u_int32_t)0x00ff0000UL) >> 8) | \
(((u_int32_t)(x) & (u_int32_t)0xff000000UL) >> 24) ))
#define ___my_swab64(x) \
((u_int64_t)( \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00000000000000ffULL) << 56) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x000000000000ff00ULL) << 40) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x0000000000ff0000ULL) << 24) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00000000ff000000ULL) << 8) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x000000ff00000000ULL) >> 8) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x0000ff0000000000ULL) >> 24) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0x00ff000000000000ULL) >> 40) | \
(u_int64_t)(((u_int64_t)(x) & (u_int64_t)0xff00000000000000ULL) >> 56) ))
/*
* Linux
*/
#if defined(linux) || defined(Linux) || defined(__linux__) || defined(__linux) || defined(__gnu_linux__)
#include <endian.h>
#include <unistd.h>
#include <stdint.h>
#ifndef __int8_t_defined
typedef uint64_t u_int64_t;
typedef uint32_t u_int32_t;
typedef uint16_t u_int16_t;
typedef uint8_t u_int8_t;
#endif
#endif
/*
* Cygwin
*/
#if defined(__CYGWIN32__)
#include <asm/byteorder.h>
#include <unistd.h>
#define __be64_to_cpu(x) ___my_swab64(x)
#define __be32_to_cpu(x) ___my_swab32(x)
#define __be16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_be64(x) ___my_swab64(x)
#define __cpu_to_be32(x) ___my_swab32(x)
#define __cpu_to_be16(x) ___my_swab16(x)
#define __le64_to_cpu(x) (x)
#define __le32_to_cpu(x) (x)
#define __le16_to_cpu(x) (x)
#define __cpu_to_le64(x) (x)
#define __cpu_to_le32(x) (x)
#define __cpu_to_le16(x) (x)
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
/*
* Windows (DDK)
*/
#if defined(__WIN__)
#include <io.h>
#define __be64_to_cpu(x) ___my_swab64(x)
#define __be32_to_cpu(x) ___my_swab32(x)
#define __be16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_be64(x) ___my_swab64(x)
#define __cpu_to_be32(x) ___my_swab32(x)
#define __cpu_to_be16(x) ___my_swab16(x)
#define __le64_to_cpu(x) (x)
#define __le32_to_cpu(x) (x)
#define __le16_to_cpu(x) (x)
#define __cpu_to_le64(x) (x)
#define __cpu_to_le32(x) (x)
#define __cpu_to_le16(x) (x)
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
/*
* MAC (Darwin)
*/
#if defined(__APPLE_CC__)
#if defined(__x86_64__) && defined(__APPLE__)
#include <libkern/OSByteOrder.h>
#define __swab64(x) (unsigned long long) OSSwapInt64((uint64_t)x)
#define __swab32(x) (unsigned long) OSSwapInt32((uint32_t)x)
#define __swab16(x) (unsigned short) OSSwapInt16((uint16_t)x)
#define __be64_to_cpu(x) (unsigned long long) OSSwapBigToHostInt64((uint64_t)x)
#define __be32_to_cpu(x) (unsigned long) OSSwapBigToHostInt32((uint32_t)x)
#define __be16_to_cpu(x) (unsigned short) OSSwapBigToHostInt16((uint16_t)x)
#define __le64_to_cpu(x) (unsigned long long) OSSwapLittleToHostInt64((uint64_t)x)
#define __le32_to_cpu(x) (unsigned long) OSSwapLittleToHostInt32((uint32_t)x)
#define __le16_to_cpu(x) (unsigned short) OSSwapLittleToHostInt16((uint16_t)x)
#define __cpu_to_be64(x) (unsigned long long) OSSwapHostToBigInt64((uint64_t)x)
#define __cpu_to_be32(x) (unsigned long) OSSwapHostToBigInt32((uint32_t)x)
#define __cpu_to_be16(x) (unsigned short) OSSwapHostToBigInt16((uint16_t)x)
#define __cpu_to_le64(x) (unsigned long long) OSSwapHostToLittleInt64((uint64_t)x)
#define __cpu_to_le32(x) (unsigned long) OSSwapHostToLittleInt32((uint32_t)x)
#define __cpu_to_le16(x) (unsigned short) OSSwapHostToLittleInt16((uint16_t)x)
#else
#include <architecture/byte_order.h>
#define __swab64(x) NXSwapLongLong(x)
#define __swab32(x) NXSwapLong(x)
#define __swab16(x) NXSwapShort(x)
#define __be64_to_cpu(x) NXSwapBigLongLongToHost(x)
#define __be32_to_cpu(x) NXSwapBigLongToHost(x)
#define __be16_to_cpu(x) NXSwapBigShortToHost(x)
#define __le64_to_cpu(x) NXSwapLittleLongLongToHost(x)
#define __le32_to_cpu(x) NXSwapLittleLongToHost(x)
#define __le16_to_cpu(x) NXSwapLittleShortToHost(x)
#define __cpu_to_be64(x) NXSwapHostLongLongToBig(x)
#define __cpu_to_be32(x) NXSwapHostLongToBig(x)
#define __cpu_to_be16(x) NXSwapHostShortToBig(x)
#define __cpu_to_le64(x) NXSwapHostLongLongToLittle(x)
#define __cpu_to_le32(x) NXSwapHostLongToLittle(x)
#define __cpu_to_le16(x) NXSwapHostShortToLittle(x)
#endif
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412
#define __BYTE_ORDER __BIG_ENDIAN
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
/*
* Solaris
* -------
*/
#if defined(__SVR4) && defined(__sun__)
#include <sys/byteorder.h>
#include <sys/types.h>
#include <unistd.h>
typedef uint64_t u_int64_t;
typedef uint32_t u_int32_t;
typedef uint16_t u_int16_t;
typedef uint8_t u_int8_t;
#if defined(__sparc__)
#define __be64_to_cpu(x) (x)
#define __be32_to_cpu(x) (x)
#define __be16_to_cpu(x) (x)
#define __cpu_to_be64(x) (x)
#define __cpu_to_be32(x) (x)
#define __cpu_to_be16(x) (x)
#define __le64_to_cpu(x) ___my_swab64(x)
#define __le32_to_cpu(x) ___my_swab32(x)
#define __le16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_le64(x) ___my_swab64(x)
#define __cpu_to_le32(x) ___my_swab32(x)
#define __cpu_to_le16(x) ___my_swab16(x)
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#else
#define AIRCRACK_NG_BYTE_ORDER 1
#define LITTLE_ENDIAN 1
#endif
#endif
/*
* Custom stuff
*/
#if defined(__MACH__) && !defined(__APPLE_CC__) && !defined(__GNU__)
#include <libkern/OSByteOrder.h>
#define __cpu_to_be64(x) = OSSwapHostToBigInt64(x)
#define __cpu_to_be32(x) = OSSwapHostToBigInt32(x)
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
// FreeBSD
#ifdef __FreeBSD__
#undef ushort
#undef uint
#include <sys/types.h>
#endif
/*
* Android
*/
#if defined(__ANDROID__)
#undef __swab16
#undef __swab32
#undef __swab64
#define __swab16(x) ___my_swab16(x)
#define __swab32(x) ___my_swab32(x)
#define __swab64(x) ___my_swab64(x)
#include <linux/byteorder/little_endian.h>
#define AIRCRACK_NG_BYTE_ORDER_DEFINED
#endif
// XXX: Is there anything to include on OpenBSD/NetBSD/DragonFlyBSD/...?
// XXX: Mac: Check path_to_url
// path_to_url
// Write to apple to ask what should be used.
#if defined(LITTLE_ENDIAN)
#define AIRCRACK_NG_LITTLE_ENDIAN LITTLE_ENDIAN
#elif defined(__LITTLE_ENDIAN)
#define AIRCRACK_NG_LITTLE_ENDIAN __LITTLE_ENDIAN
#elif defined(_LITTLE_ENDIAN)
#define AIRCRACK_NG_LITTLE_ENDIAN _LITTLE_ENDIAN
#endif
#if defined(BIG_ENDIAN)
#define AIRCRACK_NG_BIG_ENDIAN BIG_ENDIAN
#elif defined(__BIG_ENDIAN)
#define AIRCRACK_NG_BIG_ENDIAN __BIG_ENDIAN
#elif defined(_BIG_ENDIAN)
#define AIRCRACK_NG_BIG_ENDIAN _BIG_ENDIAN
#endif
#if !defined(AIRCRACK_NG_LITTLE_ENDIAN) && !defined(AIRCRACK_NG_BIG_ENDIAN)
#error Impossible to determine endianness (Little or Big endian), please contact the author.
#endif
#if defined(BYTE_ORDER)
#if (BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN
#elif (BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN
#endif
#elif defined(__BYTE_ORDER)
#if (__BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN
#elif (__BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN
#endif
#elif defined(_BYTE_ORDER)
#if (_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_LITTLE_ENDIAN
#elif (_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#define AIRCRACK_NG_BYTE_ORDER AIRCRACK_NG_BIG_ENDIAN
#endif
#endif
#ifndef AIRCRACK_NG_BYTE_ORDER
#error Impossible to determine endianness (Little or Big endian), please contact the author.
#endif
#if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_LITTLE_ENDIAN)
#ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED
#define __be64_to_cpu(x) ___my_swab64(x)
#define __be32_to_cpu(x) ___my_swab32(x)
#define __be16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_be64(x) ___my_swab64(x)
#define __cpu_to_be32(x) ___my_swab32(x)
#define __cpu_to_be16(x) ___my_swab16(x)
#define __le64_to_cpu(x) (x)
#define __le32_to_cpu(x) (x)
#define __le16_to_cpu(x) (x)
#define __cpu_to_le64(x) (x)
#define __cpu_to_le32(x) (x)
#define __cpu_to_le16(x) (x)
#endif
#ifndef htobe16
#define htobe16 ___my_swab16
#endif
#ifndef htobe32
#define htobe32 ___my_swab32
#endif
#ifndef htobe64
#define htobe64 ___my_swab64
#endif
#ifndef betoh16
#define betoh16 ___my_swab16
#endif
#ifndef betoh32
#define betoh32 ___my_swab32
#endif
#ifndef betoh64
#define betoh64 ___my_swab64
#endif
#ifndef htole16
#define htole16(x) (x)
#endif
#ifndef htole32
#define htole32(x) (x)
#endif
#ifndef htole64
#define htole64(x) (x)
#endif
#ifndef letoh16
#define letoh16(x) (x)
#endif
#ifndef letoh32
#define letoh32(x) (x)
#endif
#ifndef letoh64
#define letoh64(x) (x)
#endif
#endif
#if (AIRCRACK_NG_BYTE_ORDER == AIRCRACK_NG_BIG_ENDIAN)
#ifndef AIRCRACK_NG_BYTE_ORDER_DEFINED
#define __be64_to_cpu(x) (x)
#define __be32_to_cpu(x) (x)
#define __be16_to_cpu(x) (x)
#define __cpu_to_be64(x) (x)
#define __cpu_to_be32(x) (x)
#define __cpu_to_be16(x) (x)
#define __le64_to_cpu(x) ___my_swab64(x)
#define __le32_to_cpu(x) ___my_swab32(x)
#define __le16_to_cpu(x) ___my_swab16(x)
#define __cpu_to_le64(x) ___my_swab64(x)
#define __cpu_to_le32(x) ___my_swab32(x)
#define __cpu_to_le16(x) ___my_swab16(x)
#endif
#ifndef htobe16
#define htobe16(x) (x)
#endif
#ifndef htobe32
#define htobe32(x) (x)
#endif
#ifndef htobe64
#define htobe64(x) (x)
#endif
#ifndef betoh16
#define betoh16(x) (x)
#endif
#ifndef betoh32
#define betoh32(x) (x)
#endif
#ifndef betoh64
#define betoh64(x) (x)
#endif
#ifndef htole16
#define htole16 ___my_swab16
#endif
#ifndef htole32
#define htole32 ___my_swab32
#endif
#ifndef htole64
#define htole64 ___my_swab64
#endif
#ifndef letoh16
#define letoh16 ___my_swab16
#endif
#ifndef letoh32
#define letoh32 ___my_swab32
#endif
#ifndef letoh64
#define letoh64 ___my_swab64
#endif
#endif
// Common defines
#define cpu_to_le64 __cpu_to_le64
#define le64_to_cpu __le64_to_cpu
#define cpu_to_le32 __cpu_to_le32
#define le32_to_cpu __le32_to_cpu
#define cpu_to_le16 __cpu_to_le16
#define le16_to_cpu __le16_to_cpu
#define cpu_to_be64 __cpu_to_be64
#define be64_to_cpu __be64_to_cpu
#define cpu_to_be32 __cpu_to_be32
#define be32_to_cpu __be32_to_cpu
#define cpu_to_be16 __cpu_to_be16
#define be16_to_cpu __be16_to_cpu
#ifndef le16toh
#define le16toh le16_to_cpu
#endif
#ifndef be16toh
#define be16toh be16_to_cpu
#endif
#ifndef le32toh
#define le32toh le32_to_cpu
#endif
#ifndef be32toh
#define be32toh be32_to_cpu
#endif
#ifndef htons
#define htons be16_to_cpu
#endif
#ifndef htonl
#define htonl cpu_to_be16
#endif
#ifndef ntohs
#define ntohs cpu_to_be16
#endif
#ifndef ntohl
#define ntohl cpu_to_be32
#endif
#endif
```
|
Charles Hommer DeArmond (February 13, 1877 – December 17, 1933) was a Major League Baseball third baseman. He played for the 1903 Cincinnati Reds. DeArmond died of lobar pneumonia, and is buried in Shandon, Ohio.
References
External links
Baseball Reference page
1877 births
1933 deaths
Cincinnati Reds players
Major League Baseball third basemen
Baseball players from Ohio
Sportspeople from Butler County, Ohio
Florence Fiddlers players
|
```javascript
/*
* 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
*/
module.exports = angular.module('trafficPortal.private.divisions.regions', [])
.config(function($stateProvider, $urlRouterProvider) {
$stateProvider
.state('trafficPortal.private.divisions.regions', {
url: '/{divisionId}/regions',
views: {
divisionsContent: {
templateUrl: 'common/modules/table/divisionRegions/table.divisionRegions.tpl.html',
controller: 'TableDivisionRegionsController',
resolve: {
division: function($stateParams, divisionService) {
return divisionService.getDivision($stateParams.divisionId);
},
divisionRegions: function($stateParams, regionService) {
return regionService.getRegions({ division: $stateParams.divisionId });
}
}
}
}
})
;
$urlRouterProvider.otherwise('/');
});
```
|
```smalltalk
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//
#if !MONOTOUCH
using System;
using System.Reflection;
using System.Reflection.Emit;
namespace Mono.CodeGeneration
{
internal class CodeAssignment: CodeExpression
{
new CodeValueReference var;
CodeExpression exp;
public CodeAssignment (CodeValueReference var, CodeExpression exp)
{
if (var == null)
throw new ArgumentNullException ("var");
if (exp == null)
throw new ArgumentNullException ("exp");
this.exp = exp;
this.var = var;
}
public override void Generate (ILGenerator gen)
{
var.GenerateSet (gen, exp);
exp.Generate (gen);
}
public override void GenerateAsStatement (ILGenerator gen)
{
CodeExpression val = exp;
if (var.GetResultType () == typeof(object) && exp.GetResultType ().IsValueType)
var.GenerateSet (gen, new CodeCast (typeof(object), exp));
else
var.GenerateSet (gen, exp);
}
public override void PrintCode (CodeWriter cp)
{
var.PrintCode (cp);
cp.Write (" = ");
exp.PrintCode (cp);
}
public override Type GetResultType ()
{
return var.GetResultType ();
}
}
}
#endif
```
|
```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 providers
import (
"context"
"fmt"
"go.uber.org/zap"
kubermaticv1 "k8c.io/kubermatic/v2/pkg/apis/kubermatic/v1"
"k8c.io/kubermatic/v2/pkg/resources/cloudcontroller"
"k8c.io/kubermatic/v2/pkg/test/e2e/jig"
appsv1 "k8s.io/api/apps/v1"
ctrlruntimeclient "sigs.k8s.io/controller-runtime/pkg/client"
)
const (
osCCMDeploymentName = cloudcontroller.OpenstackCCMDeploymentName
)
type OpenstackScenario struct {
commonScenario
credentials jig.OpenstackCredentials
}
var (
_ TestScenario = &OpenstackScenario{}
)
func NewOpenstackScenario(log *zap.SugaredLogger, seedClient ctrlruntimeclient.Client, credentials jig.OpenstackCredentials) *OpenstackScenario {
return &OpenstackScenario{
commonScenario: commonScenario{
seedClient: seedClient,
testJig: jig.NewOpenstackCluster(seedClient, log, credentials, 1),
},
credentials: credentials,
}
}
func (c *OpenstackScenario) CheckComponents(ctx context.Context, cluster *kubermaticv1.Cluster, userClient ctrlruntimeclient.Client) (bool, error) {
ccmDeploy := &appsv1.Deployment{}
if err := c.seedClient.Get(ctx, ctrlruntimeclient.ObjectKey{Namespace: fmt.Sprintf("cluster-%s", cluster.Name), Name: osCCMDeploymentName}, ccmDeploy); err != nil {
return false, fmt.Errorf("failed to get %s deployment: %w", osCCMDeploymentName, err)
}
if ccmDeploy.Status.AvailableReplicas == 1 {
return true, nil
}
return false, nil
}
```
|
The 1918–19 season was the 20th season for FC Barcelona.
Results
References
External links
webdelcule.com
webdelcule.com
FC Barcelona seasons
Barcelona
|
```smalltalk
//
//
// file LICENSE or copy at path_to_url
//
using System;
using Windows.Foundation;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
namespace Telegram.Controls
{
public class HeaderedControl : ItemsControl
{
public HeaderedControl()
{
DefaultStyleKey = typeof(HeaderedControl);
//ItemContainerTransitions = new TransitionCollection
//{
// new RepositionThemeTransition()
//};
}
protected override void OnApplyTemplate()
{
VisualStateManager.GoToState(this, IsFooterAtBottom ? "FooterBottomLeft" : "FooterTopRight", false);
base.OnApplyTemplate();
}
#region Header
public string Header
{
get => (string)GetValue(HeaderProperty);
set => SetValue(HeaderProperty, value);
}
public static readonly DependencyProperty HeaderProperty =
DependencyProperty.Register("Header", typeof(string), typeof(HeaderedControl), new PropertyMetadata(null));
#endregion
#region Footer
public string Footer
{
get => (string)GetValue(FooterProperty);
set => SetValue(FooterProperty, value);
}
public static readonly DependencyProperty FooterProperty =
DependencyProperty.Register("Footer", typeof(string), typeof(HeaderedControl), new PropertyMetadata(null));
#endregion
#region IsFooterAtBottom
public bool IsFooterAtBottom
{
get { return (bool)GetValue(IsFooterAtBottomProperty); }
set { SetValue(IsFooterAtBottomProperty, value); }
}
public static readonly DependencyProperty IsFooterAtBottomProperty =
DependencyProperty.Register("IsFooterAtBottom", typeof(bool), typeof(HeaderedControl), new PropertyMetadata(true, OnIsFooterAtBottomChanged));
private static void OnIsFooterAtBottomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
((HeaderedControl)d).OnIsFooterAtBottomChanged((bool)e.NewValue, (bool)e.OldValue);
}
private void OnIsFooterAtBottomChanged(bool newValue, bool oldValue)
{
VisualStateManager.GoToState(this, newValue ? "FooterBottomLeft" : "FooterTopRight", false);
}
#endregion
#region IsFooterLink
public bool IsFooterLink
{
get { return (bool)GetValue(IsFooterLinkProperty); }
set { SetValue(IsFooterLinkProperty, value); }
}
public static readonly DependencyProperty IsFooterLinkProperty =
DependencyProperty.Register("IsFooterLink", typeof(bool), typeof(HeaderedControl), new PropertyMetadata(false));
#endregion
#region ItemPresenterStyle
public Style ItemPresenterStyle
{
get { return (Style)GetValue(ItemPresenterStyleProperty); }
set { SetValue(ItemPresenterStyleProperty, value); }
}
public static readonly DependencyProperty ItemPresenterStyleProperty =
DependencyProperty.Register("ItemPresenterStyle", typeof(Style), typeof(HeaderedControl), new PropertyMetadata(null));
#endregion
protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
{
if (element is ContentPresenter presenter)
{
presenter.Style = ItemPresenterStyle;
}
base.PrepareContainerForItemOverride(element, item);
}
public event EventHandler<TextUrlClickEventArgs> Click;
// Used by TextBlockHelper
public void OnClick(string url)
{
Click?.Invoke(this, new TextUrlClickEventArgs(url));
}
}
public class TextUrlClickEventArgs
{
public TextUrlClickEventArgs(string url)
{
Url = url;
}
public string Url { get; }
}
public class HeaderedControlPanel : StackPanel
{
protected override Size MeasureOverride(Size availableSize)
{
var last = true;
var first = default(UIElement);
for (int i = Children.Count - 1; i >= 0; i--)
{
if (Children[i].Visibility == Visibility.Visible)
{
switch (Children[i])
{
case ContentPresenter presenter:
presenter.BorderThickness = new Thickness(0, 0, 0, last ? 0 : 1);
presenter.CornerRadius = new CornerRadius(0, 0, last ? 4 : 0, last ? 4 : 0);
break;
case Control control:
control.BorderThickness = new Thickness(0, 0, 0, last ? 0 : 1);
control.CornerRadius = new CornerRadius(0, 0, last ? 4 : 0, last ? 4 : 0);
break;
case Grid grid:
grid.BorderThickness = new Thickness(0, 0, 0, last ? 0 : 1);
grid.CornerRadius = new CornerRadius(0, 0, last ? 4 : 0, last ? 4 : 0);
break;
case Border border:
border.BorderThickness = new Thickness(0, 0, 0, last ? 0 : 1);
border.CornerRadius = new CornerRadius(0, 0, last ? 4 : 0, last ? 4 : 0);
break;
}
last = false;
first = Children[i];
}
}
if (first != null)
{
switch (first)
{
case ContentPresenter presenter:
presenter.CornerRadius = new CornerRadius(4, 4, presenter.CornerRadius.BottomRight, presenter.CornerRadius.BottomLeft);
break;
case Control control:
control.CornerRadius = new CornerRadius(4, 4, control.CornerRadius.BottomRight, control.CornerRadius.BottomLeft);
break;
case Grid grid:
grid.CornerRadius = new CornerRadius(4, 4, grid.CornerRadius.BottomRight, grid.CornerRadius.BottomLeft);
break;
case Border border:
border.CornerRadius = new CornerRadius(4, 4, border.CornerRadius.BottomRight, border.CornerRadius.BottomLeft);
break;
}
}
return base.MeasureOverride(availableSize);
}
}
}
```
|
```scss
/* Will select next element after last '.elementor-general-section' */
#wpadminbar #wp-admin-bar-elementor_edit_page .elementor-general-section + .elementor-second-section {
border-block-start: 1px solid #464b50;
margin-block-start: 6px;
}
```
|
Western Slovakia () is one of the four NUTS-2 Regions of Slovakia. It was created at the same time as were the Nitra, Trnava and Trenčín regions. Western Slovakia is the most populated of the four regions of Slovakia and its GDP per capita is 69% of the European Union average (€20,600 per year).
References
NUTS 2 statistical regions of Slovakia
NUTS 2 statistical regions of the European Union
|
```c++
//
//
// 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.
//
// VulkanHpp Samples : DrawTexturedCube
// Draw a textured cube
#include "../utils/geometries.hpp"
#include "../utils/math.hpp"
#include "../utils/shaders.hpp"
#include "../utils/utils.hpp"
#include "SPIRV/GlslangToSpv.h"
#include "glslang/Public/ShaderLang.h"
#include <iostream>
#include <thread>
static char const * AppName = "DrawTexturedCube";
static char const * EngineName = "Vulkan.hpp";
int main( int /*argc*/, char ** /*argv*/ )
{
try
{
vk::Instance instance = vk::su::createInstance( AppName, EngineName, {}, vk::su::getInstanceExtensions() );
#if !defined( NDEBUG )
vk::DebugUtilsMessengerEXT debugUtilsMessenger = instance.createDebugUtilsMessengerEXT( vk::su::makeDebugUtilsMessengerCreateInfoEXT() );
#endif
vk::PhysicalDevice physicalDevice = instance.enumeratePhysicalDevices().front();
vk::su::SurfaceData surfaceData( instance, AppName, vk::Extent2D( 500, 500 ) );
std::pair<uint32_t, uint32_t> graphicsAndPresentQueueFamilyIndex = vk::su::findGraphicsAndPresentQueueFamilyIndex( physicalDevice, surfaceData.surface );
vk::Device device = vk::su::createDevice( physicalDevice, graphicsAndPresentQueueFamilyIndex.first, vk::su::getDeviceExtensions() );
vk::CommandPool commandPool = device.createCommandPool( { {}, graphicsAndPresentQueueFamilyIndex.first } );
vk::CommandBuffer commandBuffer =
device.allocateCommandBuffers( vk::CommandBufferAllocateInfo( commandPool, vk::CommandBufferLevel::ePrimary, 1 ) ).front();
vk::Queue graphicsQueue = device.getQueue( graphicsAndPresentQueueFamilyIndex.first, 0 );
vk::Queue presentQueue = device.getQueue( graphicsAndPresentQueueFamilyIndex.second, 0 );
vk::su::SwapChainData swapChainData( physicalDevice,
device,
surfaceData.surface,
surfaceData.extent,
vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferSrc,
{},
graphicsAndPresentQueueFamilyIndex.first,
graphicsAndPresentQueueFamilyIndex.second );
vk::su::DepthBufferData depthBufferData( physicalDevice, device, vk::Format::eD16Unorm, surfaceData.extent );
vk::su::TextureData textureData( physicalDevice, device );
commandBuffer.begin( vk::CommandBufferBeginInfo() );
textureData.setImage( device, commandBuffer, vk::su::CheckerboardImageGenerator() );
vk::su::BufferData uniformBufferData( physicalDevice, device, sizeof( glm::mat4x4 ), vk::BufferUsageFlagBits::eUniformBuffer );
glm::mat4x4 mvpcMatrix = vk::su::createModelViewProjectionClipMatrix( surfaceData.extent );
vk::su::copyToDevice( device, uniformBufferData.deviceMemory, mvpcMatrix );
vk::DescriptorSetLayout descriptorSetLayout =
vk::su::createDescriptorSetLayout( device,
{ { vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex },
{ vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment } } );
vk::PipelineLayout pipelineLayout = device.createPipelineLayout( vk::PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags(), descriptorSetLayout ) );
vk::RenderPass renderPass = vk::su::createRenderPass(
device, vk::su::pickSurfaceFormat( physicalDevice.getSurfaceFormatsKHR( surfaceData.surface ) ).format, depthBufferData.format );
glslang::InitializeProcess();
vk::ShaderModule vertexShaderModule = vk::su::createShaderModule( device, vk::ShaderStageFlagBits::eVertex, vertexShaderText_PT_T );
vk::ShaderModule fragmentShaderModule = vk::su::createShaderModule( device, vk::ShaderStageFlagBits::eFragment, fragmentShaderText_T_C );
glslang::FinalizeProcess();
std::vector<vk::Framebuffer> framebuffers =
vk::su::createFramebuffers( device, renderPass, swapChainData.imageViews, depthBufferData.imageView, surfaceData.extent );
vk::su::BufferData vertexBufferData( physicalDevice, device, sizeof( texturedCubeData ), vk::BufferUsageFlagBits::eVertexBuffer );
vk::su::copyToDevice( device, vertexBufferData.deviceMemory, texturedCubeData, sizeof( texturedCubeData ) / sizeof( texturedCubeData[0] ) );
vk::DescriptorPool descriptorPool =
vk::su::createDescriptorPool( device, { { vk::DescriptorType::eUniformBuffer, 1 }, { vk::DescriptorType::eCombinedImageSampler, 1 } } );
vk::DescriptorSetAllocateInfo descriptorSetAllocateInfo( descriptorPool, descriptorSetLayout );
vk::DescriptorSet descriptorSet = device.allocateDescriptorSets( descriptorSetAllocateInfo ).front();
vk::su::updateDescriptorSets( device, descriptorSet, { { vk::DescriptorType::eUniformBuffer, uniformBufferData.buffer, VK_WHOLE_SIZE, {} } }, textureData );
vk::PipelineCache pipelineCache = device.createPipelineCache( vk::PipelineCacheCreateInfo() );
vk::Pipeline graphicsPipeline = vk::su::createGraphicsPipeline( device,
pipelineCache,
std::make_pair( vertexShaderModule, nullptr ),
std::make_pair( fragmentShaderModule, nullptr ),
sizeof( texturedCubeData[0] ),
{ { vk::Format::eR32G32B32A32Sfloat, 0 }, { vk::Format::eR32G32Sfloat, 16 } },
vk::FrontFace::eClockwise,
true,
pipelineLayout,
renderPass );
/* VULKAN_KEY_START */
// Get the index of the next available swapchain image:
vk::Semaphore imageAcquiredSemaphore = device.createSemaphore( vk::SemaphoreCreateInfo() );
vk::ResultValue<uint32_t> currentBuffer = device.acquireNextImageKHR( swapChainData.swapChain, vk::su::FenceTimeout, imageAcquiredSemaphore, nullptr );
assert( currentBuffer.result == vk::Result::eSuccess );
assert( currentBuffer.value < framebuffers.size() );
// commandBuffer.begin() has already been called above!
std::array<vk::ClearValue, 2> clearValues;
clearValues[0].color = vk::ClearColorValue( 0.2f, 0.2f, 0.2f, 0.2f );
clearValues[1].depthStencil = vk::ClearDepthStencilValue( 1.0f, 0 );
vk::RenderPassBeginInfo renderPassBeginInfo(
renderPass, framebuffers[currentBuffer.value], vk::Rect2D( vk::Offset2D( 0, 0 ), surfaceData.extent ), clearValues );
commandBuffer.beginRenderPass( renderPassBeginInfo, vk::SubpassContents::eInline );
commandBuffer.bindPipeline( vk::PipelineBindPoint::eGraphics, graphicsPipeline );
commandBuffer.bindDescriptorSets( vk::PipelineBindPoint::eGraphics, pipelineLayout, 0, descriptorSet, nullptr );
commandBuffer.bindVertexBuffers( 0, vertexBufferData.buffer, { 0 } );
commandBuffer.setViewport(
0, vk::Viewport( 0.0f, 0.0f, static_cast<float>( surfaceData.extent.width ), static_cast<float>( surfaceData.extent.height ), 0.0f, 1.0f ) );
commandBuffer.setScissor( 0, vk::Rect2D( vk::Offset2D( 0, 0 ), surfaceData.extent ) );
commandBuffer.draw( 12 * 3, 1, 0, 0 );
commandBuffer.endRenderPass();
commandBuffer.end();
vk::Fence drawFence = device.createFence( vk::FenceCreateInfo() );
vk::PipelineStageFlags waitDestinationStageMask( vk::PipelineStageFlagBits::eColorAttachmentOutput );
vk::SubmitInfo submitInfo( imageAcquiredSemaphore, waitDestinationStageMask, commandBuffer );
graphicsQueue.submit( submitInfo, drawFence );
while ( vk::Result::eTimeout == device.waitForFences( drawFence, VK_TRUE, vk::su::FenceTimeout ) )
;
vk::Result result = presentQueue.presentKHR( vk::PresentInfoKHR( {}, swapChainData.swapChain, currentBuffer.value ) );
switch ( result )
{
case vk::Result::eSuccess: break;
case vk::Result::eSuboptimalKHR: std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n"; break;
default: assert( false ); // an unexpected result is returned !
}
std::this_thread::sleep_for( std::chrono::milliseconds( 1000 ) );
/* VULKAN_KEY_END */
device.waitIdle();
device.destroyFence( drawFence );
device.destroySemaphore( imageAcquiredSemaphore );
device.destroyPipeline( graphicsPipeline );
device.destroyPipelineCache( pipelineCache );
device.freeDescriptorSets( descriptorPool, descriptorSet );
device.destroyDescriptorPool( descriptorPool );
vertexBufferData.clear( device );
for ( auto framebuffer : framebuffers )
{
device.destroyFramebuffer( framebuffer );
}
device.destroyShaderModule( fragmentShaderModule );
device.destroyShaderModule( vertexShaderModule );
device.destroyRenderPass( renderPass );
device.destroyPipelineLayout( pipelineLayout );
device.destroyDescriptorSetLayout( descriptorSetLayout );
uniformBufferData.clear( device );
textureData.clear( device );
depthBufferData.clear( device );
swapChainData.clear( device );
device.freeCommandBuffers( commandPool, commandBuffer );
device.destroyCommandPool( commandPool );
device.destroy();
instance.destroySurfaceKHR( surfaceData.surface );
#if !defined( NDEBUG )
instance.destroyDebugUtilsMessengerEXT( debugUtilsMessenger );
#endif
instance.destroy();
}
catch ( vk::SystemError & err )
{
std::cout << "vk::SystemError: " << err.what() << std::endl;
exit( -1 );
}
catch ( std::exception & err )
{
std::cout << "std::exception: " << err.what() << std::endl;
exit( -1 );
}
catch ( ... )
{
std::cout << "unknown error\n";
exit( -1 );
}
return 0;
}
```
|
John Brannen may refer to:
John Brannen (basketball) (born 1974), American basketball coach
John Brannen (singer) (born 1952), American singer
|
```jsx
/**
*
* This program is free software: you can redistribute it and/or modify
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* along with this program. If not, see <path_to_url
*
*/
import React, { Component, PropTypes } from 'react'
import ToolbarButton from './ToolbarButton'
class ToolbarButtonGroup extends Component {
constructor(props) {
super(props)
this.state = {}
}
render() {
// Normalize to array and filter falsy children
const normalized = React.Children.toArray(this.props.children).filter(child => child)
const childCount = normalized.length
const clonedChildren = normalized.map((child, i) => {
if (!child) return
const isActive = this.props.activeIndexes[i] === true
let groupPosition
if (childCount === 1) {
groupPosition = ToolbarButton.GROUP_POSITION.NONE
} else {
switch (i) {
case 0:
groupPosition = ToolbarButton.GROUP_POSITION.LEFT
break
case childCount - 1:
groupPosition = ToolbarButton.GROUP_POSITION.RIGHT
break
default:
groupPosition = ToolbarButton.GROUP_POSITION.CENTER
break
}
}
return React.cloneElement(child, {
buttonState: isActive ? ToolbarButton.BUTTON_STATE.ACTIVE :
ToolbarButton.BUTTON_STATE.DEFAULT,
groupPosition: groupPosition,
theme: this.props.theme,
})
})
const style = Object.assign({}, {
display: 'flex',
flexDirection: 'row',
}, this.props.style)
return (
<div style={style}>
{clonedChildren}
</div>
)
}
}
ToolbarButtonGroup.THEME = ToolbarButton.THEME
ToolbarButtonGroup.propTypes = {
activeIndexes: PropTypes.array,
theme: PropTypes.number,
}
ToolbarButtonGroup.defaultProps = {
activeIndexes: [],
theme: ToolbarButtonGroup.THEME.LIGHT,
}
export default ToolbarButtonGroup
```
|
```objective-c
/**
******************************************************************************
* @file bl702_i2c_gpio_sim.h
* @version V1.0
* @date
* @brief This file is the standard driver header file
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT(c) 2020 Bouffalo Lab</center></h2>
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of Bouffalo Lab 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 HOLDER 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 __BL702_I2C_GPIO_SIM_H__
#define __BL702_I2C_GPIO_SIM_H__
#include "bl702_glb.h"
#include "bl702_common.h"
/** @addtogroup BL702_Peripheral_Driver
* @{
*/
/** @addtogroup I2C_GPIO_SIM
* @{
*/
/** @defgroup I2C_GPIO_SIM_Public_Types
* @{
*/
/*@} end of group I2C_GPIO_SIM_Public_Types */
/** @defgroup I2C_GPIO_SIM_Public_Functions
* @{
*/
/**
* @brief I2C Functions
*/
void I2C_GPIO_Sim_Init(GLB_GPIO_Type sclGPIOPin, GLB_GPIO_Type sdaGPIOPin);
int I2C_Start(void);
void I2C_Stop(void);
uint8_t I2C_GetAck(void);
void I2C_SendByte(uint8_t Data);
uint8_t I2C_ReadByte(uint8_t ack);
int SCCB_Init(GLB_GPIO_Type sclGPIOPin, GLB_GPIO_Type sdaGPIOPin);
int SCCB_Write(uint8_t slave_addr, uint8_t *data, uint32_t wrsize);
int SCCB_Read(uint8_t slave_addr, uint8_t *data, uint32_t rdsize);
/*@} end of group I2C_GPIO_SIM_Public_Functions */
/*@} end of group I2C_GPIO_SIM */
/*@} end of group BL702_Peripheral_Driver */
#endif /* __BL702_I2C_GPIO_SIM_H__ */
```
|
```ruby
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "Array#product" do
it "returns converted arguments using :to_ary" do
->{ [1].product(2..3) }.should raise_error(TypeError)
ar = ArraySpecs::ArrayConvertible.new(2,3)
[1].product(ar).should == [[1,2],[1,3]]
ar.called.should == :to_ary
end
it "returns converted arguments using :method_missing" do
ar = ArraySpecs::ArrayMethodMissing.new(2,3)
[1].product(ar).should == [[1,2],[1,3]]
end
it "returns the expected result" do
[1,2].product([3,4,5],[6,8]).should == [[1, 3, 6], [1, 3, 8], [1, 4, 6], [1, 4, 8], [1, 5, 6], [1, 5, 8],
[2, 3, 6], [2, 3, 8], [2, 4, 6], [2, 4, 8], [2, 5, 6], [2, 5, 8]]
end
it "has no required argument" do
[1,2].product.should == [[1],[2]]
end
it "returns an empty array when the argument is an empty array" do
[1, 2].product([]).should == []
end
it "does not attempt to produce an unreasonable number of products" do
a = (0..100).to_a
-> do
a.product(a, a, a, a, a, a, a, a, a, a)
end.should raise_error(RangeError)
end
describe "when given a block" do
it "yields all combinations in turn" do
acc = []
[1,2].product([3,4,5],[6,8]){|array| acc << array}
acc.should == [[1, 3, 6], [1, 3, 8], [1, 4, 6], [1, 4, 8], [1, 5, 6], [1, 5, 8],
[2, 3, 6], [2, 3, 8], [2, 4, 6], [2, 4, 8], [2, 5, 6], [2, 5, 8]]
acc = []
[1,2].product([3,4,5],[],[6,8]){|array| acc << array}
acc.should be_empty
end
it "returns self" do
a = [1, 2, 3].freeze
a.product([1, 2]) { |p| p.first }.should == a
end
it "will ignore unreasonable numbers of products and yield anyway" do
a = (0..100).to_a
-> do
a.product(a, a, a, a, a, a, a, a, a, a)
end.should raise_error(RangeError)
end
end
describe "when given an empty block" do
it "returns self" do
arr = [1,2]
arr.product([3,4,5],[6,8]){}.should equal(arr)
arr = []
arr.product([3,4,5],[6,8]){}.should equal(arr)
arr = [1,2]
arr.product([]){}.should equal(arr)
end
end
end
```
|
St. Petersburg, Florida is the fifth largest city in Florida with a population of 263,768 as of 2017. The city is home to 74 completed high rises (as of 2018), and the most notable are the One St. Petersburg, Priatek Plaza and Signature Place skyscrapers.
The current tallest skyscraper in the city is the One St. Petersburg. The second tallest building is the Priatek Plaza, formally known as One Progress Plaza and the Bank of America Tower. The then called One Progress Plaza, was built in 1990 at a height of with 28 stories and serves as an A-Class commercial office tower, making the tower the second tallest skyscraper in St. Petersburg and Pinellas County for more than 2 years. The third tallest skyscraper and the second tallest residential skyscraper in St. Petersburg is Signature Place standing at a height of with 36 stories and 243 residential units. The Signature Place tower has been credited for being a major transition in St. Petersburg modern architecture and surviving the financial crisis of 2008's house market crash.
St. Petersburg has recently seen an economic boom in luxury condos dating from the 1990s to early and late 2000s. The combination of tourism and wealthy residents attracted wanted large and mid sized condominiums.
Tallest buildings
This is the list of the tallest buildings in St. Petersburg, Florida that are multi-leveled and above . The (=) sign stands for buildings with the same height as another.
See also
List of tallest buildings in Florida
List of tallest buildings in Fort Lauderdale
List of tallest buildings in Jacksonville
List of tallest buildings in Miami
List of tallest buildings in Miami Beach
List of tallest buildings in Orlando
List of tallest buildings in Sunny Isles Beach
List of tallest buildings in Tampa
References
St. Petersburg
Tallest in St. Petersburg
Buildings and structures in St. Petersburg, Florida
|
Salazar is a surname meaning old hall (from Castilian Sala [hall] and Basque zahar [old]). The name originates from the town of the same name: Salazar, in northern Burgos, Castile, Spain. Although northern Burgos is not currently a Basque-speaking region, the language was spoken there when the surname appeared there during the early Middle Ages.
Its origins are also related to a certain noble family, the Salazars, that held a fief in the area. During the 10th century, the surname appears as mentioned in Navarre, where it spread and there even exists a Salazar Valley. It later also spread to the rest of the Basque Country, being specially common in Biscay during the 15th century. During that time, Lope García de Salazar, a famous writer, took part in the Reconquista of Cuenca, where he was granted a fief and founded a notable family. Some of his descendants took part in the Conquest of the Americas, thus spreading the surname all through the Spanish Americas; others intermarried many noble families, and the surname spread all through the Iberian peninsula.
Salazar is a common in Latin America because there were a number of Salazars among the early Spanish conquerors and settlers.
Salazar is also a common surname among Roma people. Due to several censuses made in the Kingdom of Castile during the 14th and 15th centuries, every Castilian subject was forced to take a name and two surnames. The Roma, who used to call themselves only by a first name, decided to take established surnames to add prestige to their families. They chose from among the oldest noble families, usually of Basque origin, thus it is extremely common to find Roma with surnames such as Heredia, Salazar, Mendoza, or Montoya.
People
Abel Salazar (actor) (1917–1995), Mexican actor, producer, and director
Abel Salazar (scientist) (1889–1946), Portuguese physician, lecturer, researcher, writer, and painter
Alberto Salazar (born 1958), American distance runner and athletics coach banned for life for emotional and sexual misconduct
Alejandro Salazar (born 1984), American soccer-player
Alexander Salazar (born 1949), Costa-Rican-American prelate of the Roman Catholic Church
Alonso de Salazar (died 1526), Spanish explorer and discoverer of Marshall Islands
Alonso Salazar Frias (c. 1564–1636), Spanish opponent of witch-trials
Anaís (Ana Isabel Salazar, born 1974), Mexican actress
Ángel Salazar (born 1956), Cuban-American comedian and actor
Antonio de Salazar (composer) (c. 1650–1715), composer and choirmaster
António de Oliveira Salazar (1889–1970), Portuguese academic and politician
Antonio Sebastián de Toledo, 2nd Marquis of Mancera (c. 1608–1715), Viceroy of New Spain
Ángel Salazar (born 1956), Cuban-American comedian and actor
Ángel Salazar (baseball) (born 1961), former Major League Baseball shortstop
Braulio Salazar (1917–2008), Venezuelan painter
Carlos Salazar (disambiguation), Argentine politician
César Salazar (born 1996), Mexican baseball player
Cristina Díaz Salazar (born 1958), Mexican politician
Diego Salazar (born 1980), Colombian weightlifter
Domingo de Salazar (1512–1594), first bishop of Manila
Eliseo Salazar (born 1954), Chilean racing driver
Elsa Salazar Cade (born 1952), U.S. entomologist
Emiliano Zapata Salazar (1879–1919), Mexican Revolution leader
Evangelina Salazar (born 1946), Argentine actress
Fanny Zampini Salazar (1853–1931), Belgian-born Italian writer, editor, and lecturer
Francisco Cervantes de Salazar (1514?–1575), Spanish theologian, writer, chronicler, and rector of the University of Mexico
Francisco Javier Salazar Sáenz, Mexican Secretary of Labor
Francisco Salazar, Chilean handball-player
Gabriel Salazar (born 1936), Chilean historian
George Salazar (born 1986), American actor
Iván Salazar (born 1998), Uruguayan soccer-player
Jeff Salazar (born 1980), Major League Baseball outfielder
John Salazar (born 1953), American politician
Jorge Ibarra Salazar, Mexican economist
José Salazar (born 1957), Venezuelan triple jumper
José Francisco Xavier de Salazar y Mendoza (1750–1802), Mexican portrait painter
José Gregorio Salazar (1773–1838), general, politician, president of the Federal Republic of Central America
Juan de Oñate y Salazar (1550–1626), Spanish explorer, conquistador & governor of New Mexico
Juan de Salazar, maestre de campo in the Arauco War
Juana de Salazar, wife of governor of Chile Antonio de Acuña Cabrera
Juan García de Salazar (1639–1710), Spanish composer
Julia Salazar, American political activist
Jocelyn ,Salazar, famous tik tok star
Kenneth Salazar (born 1955), U.S. Secretary of the Interior and former U.S. Senator from the state of Colorado
Luciana Salazar (born 1980), Argentine model and actress
Luis Salazar (born 1956), former Major League Baseball infielder/outfielder
Manuel Salazar y Baquíjano (1777–1850), President of Peru in 1827
Maria Elvira Salazar (born 1961), TV anchor and Representative for Florida's 27th Congressional seat
Marina Saiz-Salazar (1930-1990), Panamanian composer
Martha Salazar (born 1970), American boxer
Max Salazar (1932–2010), American journalist and writer on Latin music
Nick Salazar (1929–2020), American politician
Noel B. Salazar (born 1973), European sociocultural anthropologist
Oscar Salazar (baseball) (born 1978), Major League Baseball second baseman
Oscar Salazar (taekwondo) (born 1977), Olympic taekwondo athlete from Mexico
Philippe-Joseph Salazar (born 1955), French philosopher and rhetorician
Ricardo Salazar (born 1972), MLS and FIFA soccer-referee
Richard Salazar (born 1981), Venezuelan baseball pitcher
Roger Salazar (consultant) (born 1970), American former presidential and gubernatorial spokesperson
Rosa Salazar (born 1985), American actress
Rubén Salazar (1928–1970), reporter for the Los Angeles Times and KMEX-TV, Los Angeles
Tim Salazar, Wyoming State Senator
Vicente Lucio Salazar (1832–1896), President of Ecuador in 1895
Victor Salazar (1911–1985), American businessman, political figure and officeholder.
Víctor Salazar (footballer, born 1991), Colombian soccer-player
Víctor Salazar (footballer, born 1993), Argentine soccer-player
Zeus A. Salazar (born 1934), a Filipino historian, anthropologist, and philosopher of history.
Fictional characters
Armando Salazar, villain of the film Pirates of the Caribbean: Dead Men Tell No Tales
Bennie Salazar, a central character and record company executive from the book A Visit From the Goon Squad
Hector Salazar (disambiguation), multiple fictional characters
King Salazar, main antagonist of the animated film Wakko's Wish
Ramon Salazar (Resident Evil 4), from the video game Resident Evil 4
Ramon Salazar (24 character), from the television series 24
Rex Salazar, fictional titular protagonist of Generator Rex which the surname of his late Argentinean father Rafael.
Rosario Salazar, from the television series Will & Grace
Víctor Salazar, main character of the television series Love, Victor
Salazar Slytherin, Founder of the Slytherin House Harry Potter
References
Bibliography
Euskal Abizenak, vol 3, pp 100–102. Lizardi Multimedia, Zarauz, Spain.
RAMOS MERINO, Juan Luis. "La caballería y la leyenda artúrica en Lope García de Salazar". En: Junto al Grial : miscelánea artúrica. Soria : Diputación Provincial, 2008, pp. 89–103.
Basque-language surnames
Surnames of Romani origin
Spanish-language surnames
|
```javascript
<!-- Jquery js -->
<script src="path_to_url"></script>
<!-- Propeller Global js -->
<script src="path_to_url"></script>
<!-- Propeller js -->
<script type="text/javascript" src="path_to_url"></script>
```
|
```less
@import "variables";
.try-blueocean.header-callout {
position: absolute;
padding: 5px 10px;
right: 50%;
margin-right: -5em;
height: 30px !important;
top: 5px;
color: white;
border: 1px solid;
border-radius: 3px;
text-decoration: none;
}
.try-blueocean.header-callout:hover {
cursor: pointer;
}
```
|
Adventures In Missions may refer to:
Adventures In Missions (Georgia), a Christian mission program founded by Seth Barnes in 1989; see Timeline of Christian missions
Adventures In Missions (Texas), a Christian mission program founded by students of the Sunset International Bible Institute in 1973
|
```php
<?php
namespace Illuminate\Http;
use Illuminate\Http\Exceptions\HttpResponseException;
use Symfony\Component\HttpFoundation\HeaderBag;
use Throwable;
trait ResponseTrait
{
/**
* The original content of the response.
*
* @var mixed
*/
public $original;
/**
* The exception that triggered the error response (if applicable).
*
* @var \Throwable|null
*/
public $exception;
/**
* Get the status code for the response.
*
* @return int
*/
public function status()
{
return $this->getStatusCode();
}
/**
* Get the status text for the response.
*
* @return string
*/
public function statusText()
{
return $this->statusText;
}
/**
* Get the content of the response.
*
* @return string
*/
public function content()
{
return $this->getContent();
}
/**
* Get the original response content.
*
* @return mixed
*/
public function getOriginalContent()
{
$original = $this->original;
return $original instanceof self ? $original->{__FUNCTION__}() : $original;
}
/**
* Set a header on the Response.
*
* @param string $key
* @param array|string $values
* @param bool $replace
* @return $this
*/
public function header($key, $values, $replace = true)
{
$this->headers->set($key, $values, $replace);
return $this;
}
/**
* Add an array of headers to the response.
*
* @param \Symfony\Component\HttpFoundation\HeaderBag|array $headers
* @return $this
*/
public function withHeaders($headers)
{
if ($headers instanceof HeaderBag) {
$headers = $headers->all();
}
foreach ($headers as $key => $value) {
$this->headers->set($key, $value);
}
return $this;
}
/**
* Add a cookie to the response.
*
* @param \Symfony\Component\HttpFoundation\Cookie|mixed $cookie
* @return $this
*/
public function cookie($cookie)
{
return $this->withCookie(...func_get_args());
}
/**
* Add a cookie to the response.
*
* @param \Symfony\Component\HttpFoundation\Cookie|mixed $cookie
* @return $this
*/
public function withCookie($cookie)
{
if (is_string($cookie) && function_exists('cookie')) {
$cookie = cookie(...func_get_args());
}
$this->headers->setCookie($cookie);
return $this;
}
/**
* Expire a cookie when sending the response.
*
* @param \Symfony\Component\HttpFoundation\Cookie|mixed $cookie
* @param string|null $path
* @param string|null $domain
* @return $this
*/
public function withoutCookie($cookie, $path = null, $domain = null)
{
if (is_string($cookie) && function_exists('cookie')) {
$cookie = cookie($cookie, null, -2628000, $path, $domain);
}
$this->headers->setCookie($cookie);
return $this;
}
/**
* Get the callback of the response.
*
* @return string|null
*/
public function getCallback()
{
return $this->callback ?? null;
}
/**
* Set the exception to attach to the response.
*
* @param \Throwable $e
* @return $this
*/
public function withException(Throwable $e)
{
$this->exception = $e;
return $this;
}
/**
* Throws the response in a HttpResponseException instance.
*
* @return void
*
* @throws \Illuminate\Http\Exceptions\HttpResponseException
*/
public function throwResponse()
{
throw new HttpResponseException($this);
}
}
```
|
Jastrzębiec is a village in the administrative district of Gmina Lubiszyn, within Gorzów County, Lubusz Voivodeship, in western Poland. It lies approximately north-east of Lubiszyn and north-west of Gorzów Wielkopolski.
References
Villages in Gorzów County
|
Yardley Court is a private day preparatory school for boys in Tonbridge, Kent, England, founded in 1898 by Arthur Bickmore and his wife Lilian. It now forms part of Somerhill, a public school in the British sense of the term.
There are currently around 250 boys in the school, aged between 7 and 13. The school occupies a site of 152 acres just outside Tonbridge, and is self-contained on listed park land. Since its foundation the school has been located on two sites, including the current site. Originally the school was situated in Yardley Park Road, close to Tonbridge School. For the academic year 2023/24, Yardley charges £6,450 per term.
The Headmaster since 2017 is Duncan Sinclair, previously Headmaster of Taunton Preparatory School and Deputy Headmaster at St Michael's Prep School, Otford.
History
Founded in 1898, Yardley Court was in its early years run by members of the Bickmore family, initially by A.L. Bickmore and later by his sons Maurice Bickmore (MHB) and Eric Bickmore (AFB). Eric Bickmore played cricket for Oxford University (1920–21) and for Kent County Cricket Club (1919–29). Its original location was situated in Yardley Park Road, close to Tonbridge School.
In 1973 when Eric Bickmore retired, his sons John Bickmore and Michael Bickmore ran the school as joint headmasters. They were known as “Mr John” and “Mr Michael”. Mr John's wife, Mary Blaikie, was school matron and known as “Mrs John”.
In 1982 Mr John died. And in 1983, the first non-Bickmore, John Barber was appointed joint headmaster alongside Mr Michael. Mr Barber had been a senior teacher for some years prior. Mr Michael retired in 1990 and Mr Barber resigned suddenly in 1992. Mr Barber was replaced by Tony Brook. John Coakley was the Headmaster of Yardley Court and Principal from 1996 to 2017.
Yardley Court has had close links to Tonbridge School for many years. A high proportion of boys have gone on to Tonbridge, many of them winning scholarships. Some Yardley Court choristers are members of the Tonbridge School choir.
The school moved to its current site in 1990. The Yardley Park Road site was sold to a housebuilder for a substantial sum, which secured the school's future. Yardley Court was joined by Derwent Lodge in 1993, with a Pre-Prep school joining in 1996. The three schools are now known collectively as "Somerhill".
Roll of Honour
44 former students, masters, catering staff, groundsmen, butchers, milkmen and administrators lost their lives in World War I and 63 in World War II. Their names are listed on two plaques on the Roll of Honour. A wreath laying ceremony is held each year on Remembrance Day.
The OYC Roll of Honour includes Wing Commander Eric James Brindley Nicolson VC DFC, Battle of Britain fighter pilot and recipient of the Victoria Cross.
Other notable alumni
Sam Alper, inventor of the Sprite caravan and Little Chef chain of roadside restaurants.
Admiral of the Fleet Sir Edward Beckwith Ashmore, British naval officer
Vice Admiral Sir Peter William Beckwith Ashmore, British naval officer
John Bee, organist.
Eric Bickmore, cricketer and Headmaster at the school
Ian Bradley, author, academic and broadcaster.
Bernard Cheese, painter and printmaker.
Patrick Head, mechanic.
Robert Fisk, journalist.
Michael Fish, weatherman.
Gerald Ratner, businessman.
Andrew Davenport, creator of In the Night Garden and co-creator of Teletubbies.
Frederick Forsyth, novelist.
Jon Tickle, presenter.
Martin Clunes, actor and comedian.
David Marques, England and British Lions rugby player and member of 1964 America's Cup challenger team aboard the yacht Sovereign.
Patrick Moore, astronomer.
Matthew Parker, author
David Quayle, businessman and co-founder of B&Q.
Paul Rutman, producer and writer, including TV series Indian Summers and eight episodes of Vera
L. J. K. Setright, motoring journalist and author.
Ed Smith, cricketer and writer.
Al Pease, racing driver.
Elleston Trevor, author of Flight of The Phoenix and the Quiller series of espionage novels.
Jon Snow, journalist and presenter.
Peter West, presenter.
Richard Osman, presenter and novelist.
Harry Hill, comedian.
Anthony Worrall Thompson, celebrity chef.
Bob Woolmer, cricketer.
Charlie Ross, antiques expert.
Dick Strawbridge, presenter.
Charles ffrench-Constant, neurologist.
Ruaridh McConnochie, England Rugby and Bath Rugby player.
Denis Ovens, darts player.
References
Preparatory schools in Kent
1898 establishments in England
Schools in Tonbridge
|
```c++
//===- HexagonBlockRanges.cpp ---------------------------------------------===//
//
// See path_to_url for license information.
//
//===your_sha256_hash------===//
#include "HexagonBlockRanges.h"
#include "HexagonInstrInfo.h"
#include "HexagonSubtarget.h"
#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <iterator>
#include <map>
#include <utility>
using namespace llvm;
#define DEBUG_TYPE "hbr"
bool HexagonBlockRanges::IndexRange::overlaps(const IndexRange &A) const {
// If A contains start(), or "this" contains A.start(), then overlap.
IndexType S = start(), E = end(), AS = A.start(), AE = A.end();
if (AS == S)
return true;
bool SbAE = (S < AE) || (S == AE && A.TiedEnd); // S-before-AE.
bool ASbE = (AS < E) || (AS == E && TiedEnd); // AS-before-E.
if ((AS < S && SbAE) || (S < AS && ASbE))
return true;
// Otherwise no overlap.
return false;
}
bool HexagonBlockRanges::IndexRange::contains(const IndexRange &A) const {
if (start() <= A.start()) {
// Treat "None" in the range end as equal to the range start.
IndexType E = (end() != IndexType::None) ? end() : start();
IndexType AE = (A.end() != IndexType::None) ? A.end() : A.start();
if (AE <= E)
return true;
}
return false;
}
void HexagonBlockRanges::IndexRange::merge(const IndexRange &A) {
// Allow merging adjacent ranges.
assert(end() == A.start() || overlaps(A));
IndexType AS = A.start(), AE = A.end();
if (AS < start() || start() == IndexType::None)
setStart(AS);
if (end() < AE || end() == IndexType::None) {
setEnd(AE);
TiedEnd = A.TiedEnd;
} else {
if (end() == AE)
TiedEnd |= A.TiedEnd;
}
if (A.Fixed)
Fixed = true;
}
void HexagonBlockRanges::RangeList::include(const RangeList &RL) {
for (auto &R : RL)
if (!is_contained(*this, R))
push_back(R);
}
// Merge all overlapping ranges in the list, so that all that remains
// is a list of disjoint ranges.
void HexagonBlockRanges::RangeList::unionize(bool MergeAdjacent) {
if (empty())
return;
llvm::sort(begin(), end());
iterator Iter = begin();
while (Iter != end()-1) {
iterator Next = std::next(Iter);
// If MergeAdjacent is true, merge ranges A and B, where A.end == B.start.
// This allows merging dead ranges, but is not valid for live ranges.
bool Merge = MergeAdjacent && (Iter->end() == Next->start());
if (Merge || Iter->overlaps(*Next)) {
Iter->merge(*Next);
erase(Next);
continue;
}
++Iter;
}
}
// Compute a range A-B and add it to the list.
void HexagonBlockRanges::RangeList::addsub(const IndexRange &A,
const IndexRange &B) {
// Exclusion of non-overlapping ranges makes some checks simpler
// later in this function.
if (!A.overlaps(B)) {
// A - B = A.
add(A);
return;
}
IndexType AS = A.start(), AE = A.end();
IndexType BS = B.start(), BE = B.end();
// If AE is None, then A is included in B, since A and B overlap.
// The result of subtraction if empty, so just return.
if (AE == IndexType::None)
return;
if (AS < BS) {
// A starts before B.
// AE cannot be None since A and B overlap.
assert(AE != IndexType::None);
// Add the part of A that extends on the "less" side of B.
add(AS, BS, A.Fixed, false);
}
if (BE < AE) {
// BE cannot be Exit here.
if (BE == IndexType::None)
add(BS, AE, A.Fixed, false);
else
add(BE, AE, A.Fixed, false);
}
}
// Subtract a given range from each element in the list.
void HexagonBlockRanges::RangeList::subtract(const IndexRange &Range) {
// Cannot assume that the list is unionized (i.e. contains only non-
// overlapping ranges.
RangeList T;
for (iterator Next, I = begin(); I != end(); I = Next) {
IndexRange &Rg = *I;
if (Rg.overlaps(Range)) {
T.addsub(Rg, Range);
Next = this->erase(I);
} else {
Next = std::next(I);
}
}
include(T);
}
HexagonBlockRanges::InstrIndexMap::InstrIndexMap(MachineBasicBlock &B)
: Block(B) {
IndexType Idx = IndexType::First;
First = Idx;
for (auto &In : B) {
if (In.isDebugInstr())
continue;
assert(getIndex(&In) == IndexType::None && "Instruction already in map");
Map.insert(std::make_pair(Idx, &In));
++Idx;
}
Last = B.empty() ? IndexType::None : unsigned(Idx)-1;
}
MachineInstr *HexagonBlockRanges::InstrIndexMap::getInstr(IndexType Idx) const {
auto F = Map.find(Idx);
return (F != Map.end()) ? F->second : nullptr;
}
HexagonBlockRanges::IndexType HexagonBlockRanges::InstrIndexMap::getIndex(
MachineInstr *MI) const {
for (auto &I : Map)
if (I.second == MI)
return I.first;
return IndexType::None;
}
HexagonBlockRanges::IndexType HexagonBlockRanges::InstrIndexMap::getPrevIndex(
IndexType Idx) const {
assert (Idx != IndexType::None);
if (Idx == IndexType::Entry)
return IndexType::None;
if (Idx == IndexType::Exit)
return Last;
if (Idx == First)
return IndexType::Entry;
return unsigned(Idx)-1;
}
HexagonBlockRanges::IndexType HexagonBlockRanges::InstrIndexMap::getNextIndex(
IndexType Idx) const {
assert (Idx != IndexType::None);
if (Idx == IndexType::Entry)
return IndexType::First;
if (Idx == IndexType::Exit || Idx == Last)
return IndexType::None;
return unsigned(Idx)+1;
}
void HexagonBlockRanges::InstrIndexMap::replaceInstr(MachineInstr *OldMI,
MachineInstr *NewMI) {
for (auto &I : Map) {
if (I.second != OldMI)
continue;
if (NewMI != nullptr)
I.second = NewMI;
else
Map.erase(I.first);
break;
}
}
HexagonBlockRanges::HexagonBlockRanges(MachineFunction &mf)
: MF(mf), HST(mf.getSubtarget<HexagonSubtarget>()),
TII(*HST.getInstrInfo()), TRI(*HST.getRegisterInfo()),
Reserved(TRI.getReservedRegs(mf)) {
// Consider all non-allocatable registers as reserved.
for (const TargetRegisterClass *RC : TRI.regclasses()) {
if (RC->isAllocatable())
continue;
for (unsigned R : *RC)
Reserved[R] = true;
}
}
HexagonBlockRanges::RegisterSet HexagonBlockRanges::getLiveIns(
const MachineBasicBlock &B, const MachineRegisterInfo &MRI,
const TargetRegisterInfo &TRI) {
RegisterSet LiveIns;
RegisterSet Tmp;
for (auto I : B.liveins()) {
MCSubRegIndexIterator S(I.PhysReg, &TRI);
if (I.LaneMask.all() || (I.LaneMask.any() && !S.isValid())) {
Tmp.insert({I.PhysReg, 0});
continue;
}
for (; S.isValid(); ++S) {
unsigned SI = S.getSubRegIndex();
if ((I.LaneMask & TRI.getSubRegIndexLaneMask(SI)).any())
Tmp.insert({S.getSubReg(), 0});
}
}
for (auto R : Tmp) {
if (!Reserved[R.Reg])
LiveIns.insert(R);
for (auto S : expandToSubRegs(R, MRI, TRI))
if (!Reserved[S.Reg])
LiveIns.insert(S);
}
return LiveIns;
}
HexagonBlockRanges::RegisterSet HexagonBlockRanges::expandToSubRegs(
RegisterRef R, const MachineRegisterInfo &MRI,
const TargetRegisterInfo &TRI) {
RegisterSet SRs;
if (R.Sub != 0) {
SRs.insert(R);
return SRs;
}
if (Register::isPhysicalRegister(R.Reg)) {
MCSubRegIterator I(R.Reg, &TRI);
if (!I.isValid())
SRs.insert({R.Reg, 0});
for (; I.isValid(); ++I)
SRs.insert({*I, 0});
} else {
assert(Register::isVirtualRegister(R.Reg));
auto &RC = *MRI.getRegClass(R.Reg);
unsigned PReg = *RC.begin();
MCSubRegIndexIterator I(PReg, &TRI);
if (!I.isValid())
SRs.insert({R.Reg, 0});
for (; I.isValid(); ++I)
SRs.insert({R.Reg, I.getSubRegIndex()});
}
return SRs;
}
void HexagonBlockRanges::computeInitialLiveRanges(InstrIndexMap &IndexMap,
RegToRangeMap &LiveMap) {
std::map<RegisterRef,IndexType> LastDef, LastUse;
RegisterSet LiveOnEntry;
MachineBasicBlock &B = IndexMap.getBlock();
MachineRegisterInfo &MRI = B.getParent()->getRegInfo();
for (auto R : getLiveIns(B, MRI, TRI))
LiveOnEntry.insert(R);
for (auto R : LiveOnEntry)
LastDef[R] = IndexType::Entry;
auto closeRange = [&LastUse,&LastDef,&LiveMap] (RegisterRef R) -> void {
auto LD = LastDef[R], LU = LastUse[R];
if (LD == IndexType::None)
LD = IndexType::Entry;
if (LU == IndexType::None)
LU = IndexType::Exit;
LiveMap[R].add(LD, LU, false, false);
LastUse[R] = LastDef[R] = IndexType::None;
};
RegisterSet Defs, Clobbers;
for (auto &In : B) {
if (In.isDebugInstr())
continue;
IndexType Index = IndexMap.getIndex(&In);
// Process uses first.
for (auto &Op : In.operands()) {
if (!Op.isReg() || !Op.isUse() || Op.isUndef())
continue;
RegisterRef R = { Op.getReg(), Op.getSubReg() };
if (Register::isPhysicalRegister(R.Reg) && Reserved[R.Reg])
continue;
bool IsKill = Op.isKill();
for (auto S : expandToSubRegs(R, MRI, TRI)) {
LastUse[S] = Index;
if (IsKill)
closeRange(S);
}
}
// Process defs and clobbers.
Defs.clear();
Clobbers.clear();
for (auto &Op : In.operands()) {
if (!Op.isReg() || !Op.isDef() || Op.isUndef())
continue;
RegisterRef R = { Op.getReg(), Op.getSubReg() };
for (auto S : expandToSubRegs(R, MRI, TRI)) {
if (Register::isPhysicalRegister(S.Reg) && Reserved[S.Reg])
continue;
if (Op.isDead())
Clobbers.insert(S);
else
Defs.insert(S);
}
}
for (auto &Op : In.operands()) {
if (!Op.isRegMask())
continue;
const uint32_t *BM = Op.getRegMask();
for (unsigned PR = 1, N = TRI.getNumRegs(); PR != N; ++PR) {
// Skip registers that have subregisters. A register is preserved
// iff its bit is set in the regmask, so if R1:0 was preserved, both
// R1 and R0 would also be present.
if (MCSubRegIterator(PR, &TRI, false).isValid())
continue;
if (Reserved[PR])
continue;
if (BM[PR/32] & (1u << (PR%32)))
continue;
RegisterRef R = { PR, 0 };
if (!Defs.count(R))
Clobbers.insert(R);
}
}
// Defs and clobbers can overlap, e.g.
// dead %d0 = COPY %5, implicit-def %r0, implicit-def %r1
for (RegisterRef R : Defs)
Clobbers.erase(R);
// Update maps for defs.
for (RegisterRef S : Defs) {
// Defs should already be expanded into subregs.
assert(!Register::isPhysicalRegister(S.Reg) ||
!MCSubRegIterator(S.Reg, &TRI, false).isValid());
if (LastDef[S] != IndexType::None || LastUse[S] != IndexType::None)
closeRange(S);
LastDef[S] = Index;
}
// Update maps for clobbers.
for (RegisterRef S : Clobbers) {
// Clobbers should already be expanded into subregs.
assert(!Register::isPhysicalRegister(S.Reg) ||
!MCSubRegIterator(S.Reg, &TRI, false).isValid());
if (LastDef[S] != IndexType::None || LastUse[S] != IndexType::None)
closeRange(S);
// Create a single-instruction range.
LastDef[S] = LastUse[S] = Index;
closeRange(S);
}
}
// Collect live-on-exit.
RegisterSet LiveOnExit;
for (auto *SB : B.successors())
for (auto R : getLiveIns(*SB, MRI, TRI))
LiveOnExit.insert(R);
for (auto R : LiveOnExit)
LastUse[R] = IndexType::Exit;
// Process remaining registers.
RegisterSet Left;
for (auto &I : LastUse)
if (I.second != IndexType::None)
Left.insert(I.first);
for (auto &I : LastDef)
if (I.second != IndexType::None)
Left.insert(I.first);
for (auto R : Left)
closeRange(R);
// Finalize the live ranges.
for (auto &P : LiveMap)
P.second.unionize();
}
HexagonBlockRanges::RegToRangeMap HexagonBlockRanges::computeLiveMap(
InstrIndexMap &IndexMap) {
RegToRangeMap LiveMap;
LLVM_DEBUG(dbgs() << __func__ << ": index map\n" << IndexMap << '\n');
computeInitialLiveRanges(IndexMap, LiveMap);
LLVM_DEBUG(dbgs() << __func__ << ": live map\n"
<< PrintRangeMap(LiveMap, TRI) << '\n');
return LiveMap;
}
HexagonBlockRanges::RegToRangeMap HexagonBlockRanges::computeDeadMap(
InstrIndexMap &IndexMap, RegToRangeMap &LiveMap) {
RegToRangeMap DeadMap;
auto addDeadRanges = [&IndexMap,&LiveMap,&DeadMap] (RegisterRef R) -> void {
auto F = LiveMap.find(R);
if (F == LiveMap.end() || F->second.empty()) {
DeadMap[R].add(IndexType::Entry, IndexType::Exit, false, false);
return;
}
RangeList &RL = F->second;
RangeList::iterator A = RL.begin(), Z = RL.end()-1;
// Try to create the initial range.
if (A->start() != IndexType::Entry) {
IndexType DE = IndexMap.getPrevIndex(A->start());
if (DE != IndexType::Entry)
DeadMap[R].add(IndexType::Entry, DE, false, false);
}
while (A != Z) {
// Creating a dead range that follows A. Pay attention to empty
// ranges (i.e. those ending with "None").
IndexType AE = (A->end() == IndexType::None) ? A->start() : A->end();
IndexType DS = IndexMap.getNextIndex(AE);
++A;
IndexType DE = IndexMap.getPrevIndex(A->start());
if (DS < DE)
DeadMap[R].add(DS, DE, false, false);
}
// Try to create the final range.
if (Z->end() != IndexType::Exit) {
IndexType ZE = (Z->end() == IndexType::None) ? Z->start() : Z->end();
IndexType DS = IndexMap.getNextIndex(ZE);
if (DS < IndexType::Exit)
DeadMap[R].add(DS, IndexType::Exit, false, false);
}
};
MachineFunction &MF = *IndexMap.getBlock().getParent();
auto &MRI = MF.getRegInfo();
unsigned NumRegs = TRI.getNumRegs();
BitVector Visited(NumRegs);
for (unsigned R = 1; R < NumRegs; ++R) {
for (auto S : expandToSubRegs({R,0}, MRI, TRI)) {
if (Reserved[S.Reg] || Visited[S.Reg])
continue;
addDeadRanges(S);
Visited[S.Reg] = true;
}
}
for (auto &P : LiveMap)
if (Register::isVirtualRegister(P.first.Reg))
addDeadRanges(P.first);
LLVM_DEBUG(dbgs() << __func__ << ": dead map\n"
<< PrintRangeMap(DeadMap, TRI) << '\n');
return DeadMap;
}
raw_ostream &llvm::operator<<(raw_ostream &OS,
HexagonBlockRanges::IndexType Idx) {
if (Idx == HexagonBlockRanges::IndexType::None)
return OS << '-';
if (Idx == HexagonBlockRanges::IndexType::Entry)
return OS << 'n';
if (Idx == HexagonBlockRanges::IndexType::Exit)
return OS << 'x';
return OS << unsigned(Idx)-HexagonBlockRanges::IndexType::First+1;
}
// A mapping to translate between instructions and their indices.
raw_ostream &llvm::operator<<(raw_ostream &OS,
const HexagonBlockRanges::IndexRange &IR) {
OS << '[' << IR.start() << ':' << IR.end() << (IR.TiedEnd ? '}' : ']');
if (IR.Fixed)
OS << '!';
return OS;
}
raw_ostream &llvm::operator<<(raw_ostream &OS,
const HexagonBlockRanges::RangeList &RL) {
for (auto &R : RL)
OS << R << " ";
return OS;
}
raw_ostream &llvm::operator<<(raw_ostream &OS,
const HexagonBlockRanges::InstrIndexMap &M) {
for (auto &In : M.Block) {
HexagonBlockRanges::IndexType Idx = M.getIndex(&In);
OS << Idx << (Idx == M.Last ? ". " : " ") << In;
}
return OS;
}
raw_ostream &llvm::operator<<(raw_ostream &OS,
const HexagonBlockRanges::PrintRangeMap &P) {
for (auto &I : P.Map) {
const HexagonBlockRanges::RangeList &RL = I.second;
OS << printReg(I.first.Reg, &P.TRI, I.first.Sub) << " -> " << RL << "\n";
}
return OS;
}
```
|
```c++
#include <vespa/log/log.h>
LOG_SETUP("summaryfeatures_test");
#include <vespa/vespalib/testkit/test_kit.h>
#include <vespa/vespalib/util/featureset.h>
using vespalib::FeatureSet;
using vespalib::Memory;
TEST("summaryfeatures_test") {
{
FeatureSet sf;
EXPECT_EQUAL(sf.getNames().size(), 0u);
EXPECT_EQUAL(sf.numFeatures(), 0u);
EXPECT_EQUAL(sf.numDocs(), 0u);
EXPECT_TRUE(sf.getFeaturesByIndex(0) == 0);
EXPECT_TRUE(sf.getFeaturesByDocId(0) == 0);
std::vector<uint32_t> docs;
EXPECT_TRUE(sf.contains(docs));
docs.push_back(1);
EXPECT_TRUE(!sf.contains(docs));
}
{
FeatureSet::StringVector n;
n.push_back("f1");
n.push_back("f2");
n.push_back("f3");
FeatureSet sf(n, 5);
EXPECT_EQUAL(sf.getNames().size(), 3u);
EXPECT_EQUAL(sf.getNames()[0], "f1");
EXPECT_EQUAL(sf.getNames()[1], "f2");
EXPECT_EQUAL(sf.getNames()[2], "f3");
EXPECT_EQUAL(sf.numFeatures(), 3u);
EXPECT_EQUAL(sf.numDocs(), 0u);
EXPECT_EQUAL(sf.addDocId(10), 0u);
EXPECT_EQUAL(sf.addDocId(20), 1u);
EXPECT_EQUAL(sf.addDocId(30), 2u);
EXPECT_EQUAL(sf.addDocId(40), 3u);
EXPECT_EQUAL(sf.addDocId(50), 4u);
EXPECT_EQUAL(sf.numDocs(), 5u);
FeatureSet::Value *f;
const FeatureSet::Value *cf;
f = sf.getFeaturesByIndex(0);
ASSERT_TRUE(f != 0);
f[0].set_double(11.0);
f[1].set_double(12.0);
f[2].set_double(13.0);
f = sf.getFeaturesByIndex(1);
ASSERT_TRUE(f != 0);
f[0].set_double(21.0);
f[1].set_double(22.0);
f[2].set_double(23.0);
f = sf.getFeaturesByIndex(2);
ASSERT_TRUE(f != 0);
f[0].set_double(31.0);
f[1].set_double(32.0);
f[2].set_double(33.0);
f = sf.getFeaturesByIndex(3);
ASSERT_TRUE(f != 0);
f[0].set_double(41.0);
f[1].set_data(Memory("test", 4));
f[2].set_double(43.0);
f = sf.getFeaturesByIndex(4);
ASSERT_TRUE(f != 0);
f[0].set_double(51.0);
f[1].set_double(52.0);
f[2].set_double(53.0);
EXPECT_TRUE(sf.getFeaturesByIndex(5) == nullptr);
{
std::vector<uint32_t> docs;
EXPECT_TRUE(sf.contains(docs));
}
{
std::vector<uint32_t> docs;
docs.push_back(1);
EXPECT_TRUE(!sf.contains(docs));
}
{
std::vector<uint32_t> docs;
docs.push_back(31);
EXPECT_TRUE(!sf.contains(docs));
}
{
std::vector<uint32_t> docs;
docs.push_back(51);
EXPECT_TRUE(!sf.contains(docs));
}
{
std::vector<uint32_t> docs;
docs.push_back(20);
docs.push_back(40);
EXPECT_TRUE(sf.contains(docs));
}
{
std::vector<uint32_t> docs;
docs.push_back(10);
docs.push_back(20);
docs.push_back(30);
docs.push_back(40);
docs.push_back(50);
EXPECT_TRUE(sf.contains(docs));
}
{
cf = sf.getFeaturesByDocId(10);
ASSERT_TRUE(cf != nullptr);
EXPECT_APPROX(cf[0].as_double(), 11.0, 10e-6);
EXPECT_APPROX(cf[1].as_double(), 12.0, 10e-6);
EXPECT_APPROX(cf[2].as_double(), 13.0, 10e-6);
}
{
cf = sf.getFeaturesByDocId(20);
ASSERT_TRUE(cf != nullptr);
EXPECT_APPROX(cf[0].as_double(), 21.0, 10e-6);
EXPECT_APPROX(cf[1].as_double(), 22.0, 10e-6);
EXPECT_APPROX(cf[2].as_double(), 23.0, 10e-6);
}
{
cf = sf.getFeaturesByDocId(30);
ASSERT_TRUE(cf != nullptr);
EXPECT_APPROX(cf[0].as_double(), 31.0, 10e-6);
EXPECT_APPROX(cf[1].as_double(), 32.0, 10e-6);
EXPECT_APPROX(cf[2].as_double(), 33.0, 10e-6);
}
{
cf = sf.getFeaturesByDocId(40);
ASSERT_TRUE(cf != nullptr);
EXPECT_TRUE(cf[0].is_double());
EXPECT_TRUE(!cf[0].is_data());
EXPECT_EQUAL(cf[0].as_double(), 41.0);
EXPECT_TRUE(!cf[1].is_double());
EXPECT_TRUE(cf[1].is_data());
EXPECT_EQUAL(cf[1].as_data(), Memory("test", 4));
EXPECT_EQUAL(cf[2].as_double(), 43.0);
}
{
cf = sf.getFeaturesByDocId(50);
ASSERT_TRUE(cf != nullptr);
EXPECT_APPROX(cf[0].as_double(), 51.0, 10e-6);
EXPECT_APPROX(cf[1].as_double(), 52.0, 10e-6);
EXPECT_APPROX(cf[2].as_double(), 53.0, 10e-6);
}
EXPECT_TRUE(sf.getFeaturesByDocId(5) == nullptr);
EXPECT_TRUE(sf.getFeaturesByDocId(15) == nullptr);
EXPECT_TRUE(sf.getFeaturesByDocId(25) == nullptr);
EXPECT_TRUE(sf.getFeaturesByDocId(35) == nullptr);
EXPECT_TRUE(sf.getFeaturesByDocId(45) == nullptr);
EXPECT_TRUE(sf.getFeaturesByDocId(55) == nullptr);
}
}
TEST_MAIN() { TEST_RUN_ALL(); }
```
|
```xml
/** @jsx jsx */
import { Transforms } from 'slate'
import { jsx } from '../../..'
export const run = editor => {
Transforms.wrapNodes(editor, <inline a />)
}
export const input = (
<editor>
<block>
<text />
<inline>
wo
<anchor />
rd
</inline>
<text />
</block>
<block>
<text />
<inline>
an
<focus />
other
</inline>
<text />
</block>
</editor>
)
export const output = (
<editor>
<block>
<text />
<inline a>
<text />
<inline>
wo
<anchor />
rd
</inline>
<text />
</inline>
<text />
</block>
<block>
<text />
<inline a>
<text />
<inline>
an
<focus />
other
</inline>
<text />
</inline>
<text />
</block>
</editor>
)
```
|
Leptochoeridae is an extinct family of basal artiodactyl mammals from the early Eocene to late Oligocene of North America.
Taxonomy
Leptochoeridae was considered a subfamily of Dichobunidae by McKenna and Bell (1997). However, Theodor et al. (2007) treat leptochoerids as a distinct family.
Genera
Ibarus
Laredochoerus
Leptochoerus
Stibarus
References
Eocene even-toed ungulates
Oligocene even-toed ungulates
Eocene first appearances
Chattian extinctions
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.