text
stringlengths 1
22.8M
|
|---|
MRFC may refer to:
Rugby union
Malvern RFC
Medicals RFC
Melbourne Rugby Football Club
Moseley Rugby Football Club
München RFC
Football
Maine Road F.C.
Mid Rhondda F.C.
Montrose Roselea F.C.
Other uses
Media Resource Function controller, a component of the Media Resource Function, defined by the IP Multimedia Subsystem (IMS) standard
Mixed reactant fuel cell, a type of Membraneless Fuel Cells
|
Cabuyao station is a railway station located on the South Main Line in Laguna, Philippines.
References
Philippine National Railways stations
Railway stations in Laguna (province)
Buildings and structures in Cabuyao
|
The Federal Office for Civil Protection (FSVO) (, , ) is the federal office responsible for the civil defense services of the Swiss cantons and municipalities. It is subordinated to the Federal Department of Defence, Civil Protection and Sport.
Tasks
The role of the Federal Office for Civil Protection is to ensure the co-ordination of leadership, protection, rescue and assistance in co-operation with the five pillars of civil protection, i.e. the police, the fire brigade, civil protection, technical services (water, electricity, communication) and public health services in the event of a disaster, emergency or armed conflict.
The FSVO consists of six business units, including:
Spiez Laboratory (the national institute for protection against atomic, biological and chemical threats and risks)
National Emergency Operations Centre: responsible for warning the population in the event of an emergency
References
External links
Federal offices of Switzerland
|
```objective-c
#ifndef CAPSTONE_ARM_H
#define CAPSTONE_ARM_H
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2015 */
#ifdef __cplusplus
extern "C" {
#endif
#include "platform.h"
#ifdef _MSC_VER
#pragma warning(disable:4201)
#endif
//> ARM shift type
typedef enum arm_shifter
{
ARM_SFT_INVALID = 0,
ARM_SFT_ASR, // shift with immediate const
ARM_SFT_LSL, // shift with immediate const
ARM_SFT_LSR, // shift with immediate const
ARM_SFT_ROR, // shift with immediate const
ARM_SFT_RRX, // shift with immediate const
ARM_SFT_ASR_REG, // shift with register
ARM_SFT_LSL_REG, // shift with register
ARM_SFT_LSR_REG, // shift with register
ARM_SFT_ROR_REG, // shift with register
ARM_SFT_RRX_REG, // shift with register
} arm_shifter;
//> ARM condition code
typedef enum arm_cc
{
ARM_CC_INVALID = 0,
ARM_CC_EQ, // Equal Equal
ARM_CC_NE, // Not equal Not equal, or unordered
ARM_CC_HS, // Carry set >, ==, or unordered
ARM_CC_LO, // Carry clear Less than
ARM_CC_MI, // Minus, negative Less than
ARM_CC_PL, // Plus, positive or zero >, ==, or unordered
ARM_CC_VS, // Overflow Unordered
ARM_CC_VC, // No overflow Not unordered
ARM_CC_HI, // Unsigned higher Greater than, or unordered
ARM_CC_LS, // Unsigned lower or same Less than or equal
ARM_CC_GE, // Greater than or equal Greater than or equal
ARM_CC_LT, // Less than Less than, or unordered
ARM_CC_GT, // Greater than Greater than
ARM_CC_LE, // Less than or equal <, ==, or unordered
ARM_CC_AL // Always (unconditional) Always (unconditional)
} arm_cc;
typedef enum arm_sysreg
{
//> Special registers for MSR
ARM_SYSREG_INVALID = 0,
// SPSR* registers can be OR combined
ARM_SYSREG_SPSR_C = 1,
ARM_SYSREG_SPSR_X = 2,
ARM_SYSREG_SPSR_S = 4,
ARM_SYSREG_SPSR_F = 8,
// CPSR* registers can be OR combined
ARM_SYSREG_CPSR_C = 16,
ARM_SYSREG_CPSR_X = 32,
ARM_SYSREG_CPSR_S = 64,
ARM_SYSREG_CPSR_F = 128,
// independent registers
ARM_SYSREG_APSR = 256,
ARM_SYSREG_APSR_G,
ARM_SYSREG_APSR_NZCVQ,
ARM_SYSREG_APSR_NZCVQG,
ARM_SYSREG_IAPSR,
ARM_SYSREG_IAPSR_G,
ARM_SYSREG_IAPSR_NZCVQG,
ARM_SYSREG_IAPSR_NZCVQ,
ARM_SYSREG_EAPSR,
ARM_SYSREG_EAPSR_G,
ARM_SYSREG_EAPSR_NZCVQG,
ARM_SYSREG_EAPSR_NZCVQ,
ARM_SYSREG_XPSR,
ARM_SYSREG_XPSR_G,
ARM_SYSREG_XPSR_NZCVQG,
ARM_SYSREG_XPSR_NZCVQ,
ARM_SYSREG_IPSR,
ARM_SYSREG_EPSR,
ARM_SYSREG_IEPSR,
ARM_SYSREG_MSP,
ARM_SYSREG_PSP,
ARM_SYSREG_PRIMASK,
ARM_SYSREG_BASEPRI,
ARM_SYSREG_BASEPRI_MAX,
ARM_SYSREG_FAULTMASK,
ARM_SYSREG_CONTROL,
// Banked Registers
ARM_SYSREG_R8_USR,
ARM_SYSREG_R9_USR,
ARM_SYSREG_R10_USR,
ARM_SYSREG_R11_USR,
ARM_SYSREG_R12_USR,
ARM_SYSREG_SP_USR,
ARM_SYSREG_LR_USR,
ARM_SYSREG_R8_FIQ,
ARM_SYSREG_R9_FIQ,
ARM_SYSREG_R10_FIQ,
ARM_SYSREG_R11_FIQ,
ARM_SYSREG_R12_FIQ,
ARM_SYSREG_SP_FIQ,
ARM_SYSREG_LR_FIQ,
ARM_SYSREG_LR_IRQ,
ARM_SYSREG_SP_IRQ,
ARM_SYSREG_LR_SVC,
ARM_SYSREG_SP_SVC,
ARM_SYSREG_LR_ABT,
ARM_SYSREG_SP_ABT,
ARM_SYSREG_LR_UND,
ARM_SYSREG_SP_UND,
ARM_SYSREG_LR_MON,
ARM_SYSREG_SP_MON,
ARM_SYSREG_ELR_HYP,
ARM_SYSREG_SP_HYP,
ARM_SYSREG_SPSR_FIQ,
ARM_SYSREG_SPSR_IRQ,
ARM_SYSREG_SPSR_SVC,
ARM_SYSREG_SPSR_ABT,
ARM_SYSREG_SPSR_UND,
ARM_SYSREG_SPSR_MON,
ARM_SYSREG_SPSR_HYP,
} arm_sysreg;
//> The memory barrier constants map directly to the 4-bit encoding of
//> the option field for Memory Barrier operations.
typedef enum arm_mem_barrier
{
ARM_MB_INVALID = 0,
ARM_MB_RESERVED_0,
ARM_MB_OSHLD,
ARM_MB_OSHST,
ARM_MB_OSH,
ARM_MB_RESERVED_4,
ARM_MB_NSHLD,
ARM_MB_NSHST,
ARM_MB_NSH,
ARM_MB_RESERVED_8,
ARM_MB_ISHLD,
ARM_MB_ISHST,
ARM_MB_ISH,
ARM_MB_RESERVED_12,
ARM_MB_LD,
ARM_MB_ST,
ARM_MB_SY,
} arm_mem_barrier;
//> Operand type for instruction's operands
typedef enum arm_op_type
{
ARM_OP_INVALID = 0, // = CS_OP_INVALID (Uninitialized).
ARM_OP_REG, // = CS_OP_REG (Register operand).
ARM_OP_IMM, // = CS_OP_IMM (Immediate operand).
ARM_OP_MEM, // = CS_OP_MEM (Memory operand).
ARM_OP_FP, // = CS_OP_FP (Floating-Point operand).
ARM_OP_CIMM = 64, // C-Immediate (coprocessor registers)
ARM_OP_PIMM, // P-Immediate (coprocessor registers)
ARM_OP_SETEND, // operand for SETEND instruction
ARM_OP_SYSREG, // MSR/MSR special register operand
} arm_op_type;
//> Operand type for SETEND instruction
typedef enum arm_setend_type
{
ARM_SETEND_INVALID = 0, // Uninitialized.
ARM_SETEND_BE, // BE operand.
ARM_SETEND_LE, // LE operand
} arm_setend_type;
typedef enum arm_cpsmode_type
{
ARM_CPSMODE_INVALID = 0,
ARM_CPSMODE_IE = 2,
ARM_CPSMODE_ID = 3
} arm_cpsmode_type;
//> Operand type for SETEND instruction
typedef enum arm_cpsflag_type
{
ARM_CPSFLAG_INVALID = 0,
ARM_CPSFLAG_F = 1,
ARM_CPSFLAG_I = 2,
ARM_CPSFLAG_A = 4,
ARM_CPSFLAG_NONE = 16, // no flag
} arm_cpsflag_type;
//> Data type for elements of vector instructions.
typedef enum arm_vectordata_type
{
ARM_VECTORDATA_INVALID = 0,
// Integer type
ARM_VECTORDATA_I8,
ARM_VECTORDATA_I16,
ARM_VECTORDATA_I32,
ARM_VECTORDATA_I64,
// Signed integer type
ARM_VECTORDATA_S8,
ARM_VECTORDATA_S16,
ARM_VECTORDATA_S32,
ARM_VECTORDATA_S64,
// Unsigned integer type
ARM_VECTORDATA_U8,
ARM_VECTORDATA_U16,
ARM_VECTORDATA_U32,
ARM_VECTORDATA_U64,
// Data type for VMUL/VMULL
ARM_VECTORDATA_P8,
// Floating type
ARM_VECTORDATA_F32,
ARM_VECTORDATA_F64,
// Convert float <-> float
ARM_VECTORDATA_F16F64, // f16.f64
ARM_VECTORDATA_F64F16, // f64.f16
ARM_VECTORDATA_F32F16, // f32.f16
ARM_VECTORDATA_F16F32, // f32.f16
ARM_VECTORDATA_F64F32, // f64.f32
ARM_VECTORDATA_F32F64, // f32.f64
// Convert integer <-> float
ARM_VECTORDATA_S32F32, // s32.f32
ARM_VECTORDATA_U32F32, // u32.f32
ARM_VECTORDATA_F32S32, // f32.s32
ARM_VECTORDATA_F32U32, // f32.u32
ARM_VECTORDATA_F64S16, // f64.s16
ARM_VECTORDATA_F32S16, // f32.s16
ARM_VECTORDATA_F64S32, // f64.s32
ARM_VECTORDATA_S16F64, // s16.f64
ARM_VECTORDATA_S16F32, // s16.f64
ARM_VECTORDATA_S32F64, // s32.f64
ARM_VECTORDATA_U16F64, // u16.f64
ARM_VECTORDATA_U16F32, // u16.f32
ARM_VECTORDATA_U32F64, // u32.f64
ARM_VECTORDATA_F64U16, // f64.u16
ARM_VECTORDATA_F32U16, // f32.u16
ARM_VECTORDATA_F64U32, // f64.u32
} arm_vectordata_type;
//> ARM registers
typedef enum arm_reg
{
ARM_REG_INVALID = 0,
ARM_REG_APSR,
ARM_REG_APSR_NZCV,
ARM_REG_CPSR,
ARM_REG_FPEXC,
ARM_REG_FPINST,
ARM_REG_FPSCR,
ARM_REG_FPSCR_NZCV,
ARM_REG_FPSID,
ARM_REG_ITSTATE,
ARM_REG_LR,
ARM_REG_PC,
ARM_REG_SP,
ARM_REG_SPSR,
ARM_REG_D0,
ARM_REG_D1,
ARM_REG_D2,
ARM_REG_D3,
ARM_REG_D4,
ARM_REG_D5,
ARM_REG_D6,
ARM_REG_D7,
ARM_REG_D8,
ARM_REG_D9,
ARM_REG_D10,
ARM_REG_D11,
ARM_REG_D12,
ARM_REG_D13,
ARM_REG_D14,
ARM_REG_D15,
ARM_REG_D16,
ARM_REG_D17,
ARM_REG_D18,
ARM_REG_D19,
ARM_REG_D20,
ARM_REG_D21,
ARM_REG_D22,
ARM_REG_D23,
ARM_REG_D24,
ARM_REG_D25,
ARM_REG_D26,
ARM_REG_D27,
ARM_REG_D28,
ARM_REG_D29,
ARM_REG_D30,
ARM_REG_D31,
ARM_REG_FPINST2,
ARM_REG_MVFR0,
ARM_REG_MVFR1,
ARM_REG_MVFR2,
ARM_REG_Q0,
ARM_REG_Q1,
ARM_REG_Q2,
ARM_REG_Q3,
ARM_REG_Q4,
ARM_REG_Q5,
ARM_REG_Q6,
ARM_REG_Q7,
ARM_REG_Q8,
ARM_REG_Q9,
ARM_REG_Q10,
ARM_REG_Q11,
ARM_REG_Q12,
ARM_REG_Q13,
ARM_REG_Q14,
ARM_REG_Q15,
ARM_REG_R0,
ARM_REG_R1,
ARM_REG_R2,
ARM_REG_R3,
ARM_REG_R4,
ARM_REG_R5,
ARM_REG_R6,
ARM_REG_R7,
ARM_REG_R8,
ARM_REG_R9,
ARM_REG_R10,
ARM_REG_R11,
ARM_REG_R12,
ARM_REG_S0,
ARM_REG_S1,
ARM_REG_S2,
ARM_REG_S3,
ARM_REG_S4,
ARM_REG_S5,
ARM_REG_S6,
ARM_REG_S7,
ARM_REG_S8,
ARM_REG_S9,
ARM_REG_S10,
ARM_REG_S11,
ARM_REG_S12,
ARM_REG_S13,
ARM_REG_S14,
ARM_REG_S15,
ARM_REG_S16,
ARM_REG_S17,
ARM_REG_S18,
ARM_REG_S19,
ARM_REG_S20,
ARM_REG_S21,
ARM_REG_S22,
ARM_REG_S23,
ARM_REG_S24,
ARM_REG_S25,
ARM_REG_S26,
ARM_REG_S27,
ARM_REG_S28,
ARM_REG_S29,
ARM_REG_S30,
ARM_REG_S31,
ARM_REG_ENDING, // <-- mark the end of the list or registers
//> alias registers
ARM_REG_R13 = ARM_REG_SP,
ARM_REG_R14 = ARM_REG_LR,
ARM_REG_R15 = ARM_REG_PC,
ARM_REG_SB = ARM_REG_R9,
ARM_REG_SL = ARM_REG_R10,
ARM_REG_FP = ARM_REG_R11,
ARM_REG_IP = ARM_REG_R12,
} arm_reg;
// Instruction's operand referring to memory
// This is associated with ARM_OP_MEM operand type above
typedef struct arm_op_mem
{
arm_reg base; // base register
arm_reg index; // index register
int scale; // scale for index register (can be 1, or -1)
int disp; // displacement/offset value
int lshift; // left-shift on index register, or 0 if irrelevant.
} arm_op_mem;
// Instruction operand
typedef struct cs_arm_op
{
int vector_index; // Vector Index for some vector operands (or -1 if irrelevant)
struct
{
arm_shifter type;
unsigned int value;
} shift;
arm_op_type type; // operand type
union
{
int reg; // register value for REG/SYSREG operand
int32_t imm; // immediate value for C-IMM, P-IMM or IMM operand
double fp; // floating point value for FP operand
arm_op_mem mem; // base/index/scale/disp value for MEM operand
arm_setend_type setend; // SETEND instruction's operand type
};
// in some instructions, an operand can be subtracted or added to
// the base register,
bool subtracted; // if TRUE, this operand is subtracted. otherwise, it is added.
// How is this operand accessed? (READ, WRITE or READ|WRITE)
// This field is combined of cs_ac_type.
// NOTE: this field is irrelevant if engine is compiled in DIET mode.
uint8_t access;
// Neon lane index for NEON instructions (or -1 if irrelevant)
int8_t neon_lane;
} cs_arm_op;
// Instruction structure
typedef struct cs_arm
{
bool usermode; // User-mode registers to be loaded (for LDM/STM instructions)
int vector_size; // Scalar size for vector instructions
arm_vectordata_type vector_data; // Data type for elements of vector instructions
arm_cpsmode_type cps_mode; // CPS mode for CPS instruction
arm_cpsflag_type cps_flag; // CPS mode for CPS instruction
arm_cc cc; // conditional code for this insn
bool update_flags; // does this insn update flags?
bool writeback; // does this insn write-back?
arm_mem_barrier mem_barrier; // Option for some memory barrier instructions
// Number of operands of this instruction,
// or 0 when instruction has no operand.
uint8_t op_count;
cs_arm_op operands[36]; // operands for this instruction.
} cs_arm;
//> ARM instruction
typedef enum arm_insn
{
ARM_INS_INVALID = 0,
ARM_INS_ADC,
ARM_INS_ADD,
ARM_INS_ADR,
ARM_INS_AESD,
ARM_INS_AESE,
ARM_INS_AESIMC,
ARM_INS_AESMC,
ARM_INS_AND,
ARM_INS_BFC,
ARM_INS_BFI,
ARM_INS_BIC,
ARM_INS_BKPT,
ARM_INS_BL,
ARM_INS_BLX,
ARM_INS_BX,
ARM_INS_BXJ,
ARM_INS_B,
ARM_INS_CDP,
ARM_INS_CDP2,
ARM_INS_CLREX,
ARM_INS_CLZ,
ARM_INS_CMN,
ARM_INS_CMP,
ARM_INS_CPS,
ARM_INS_CRC32B,
ARM_INS_CRC32CB,
ARM_INS_CRC32CH,
ARM_INS_CRC32CW,
ARM_INS_CRC32H,
ARM_INS_CRC32W,
ARM_INS_DBG,
ARM_INS_DMB,
ARM_INS_DSB,
ARM_INS_EOR,
ARM_INS_ERET,
ARM_INS_VMOV,
ARM_INS_FLDMDBX,
ARM_INS_FLDMIAX,
ARM_INS_VMRS,
ARM_INS_FSTMDBX,
ARM_INS_FSTMIAX,
ARM_INS_HINT,
ARM_INS_HLT,
ARM_INS_HVC,
ARM_INS_ISB,
ARM_INS_LDA,
ARM_INS_LDAB,
ARM_INS_LDAEX,
ARM_INS_LDAEXB,
ARM_INS_LDAEXD,
ARM_INS_LDAEXH,
ARM_INS_LDAH,
ARM_INS_LDC2L,
ARM_INS_LDC2,
ARM_INS_LDCL,
ARM_INS_LDC,
ARM_INS_LDMDA,
ARM_INS_LDMDB,
ARM_INS_LDM,
ARM_INS_LDMIB,
ARM_INS_LDRBT,
ARM_INS_LDRB,
ARM_INS_LDRD,
ARM_INS_LDREX,
ARM_INS_LDREXB,
ARM_INS_LDREXD,
ARM_INS_LDREXH,
ARM_INS_LDRH,
ARM_INS_LDRHT,
ARM_INS_LDRSB,
ARM_INS_LDRSBT,
ARM_INS_LDRSH,
ARM_INS_LDRSHT,
ARM_INS_LDRT,
ARM_INS_LDR,
ARM_INS_MCR,
ARM_INS_MCR2,
ARM_INS_MCRR,
ARM_INS_MCRR2,
ARM_INS_MLA,
ARM_INS_MLS,
ARM_INS_MOV,
ARM_INS_MOVT,
ARM_INS_MOVW,
ARM_INS_MRC,
ARM_INS_MRC2,
ARM_INS_MRRC,
ARM_INS_MRRC2,
ARM_INS_MRS,
ARM_INS_MSR,
ARM_INS_MUL,
ARM_INS_MVN,
ARM_INS_ORR,
ARM_INS_PKHBT,
ARM_INS_PKHTB,
ARM_INS_PLDW,
ARM_INS_PLD,
ARM_INS_PLI,
ARM_INS_QADD,
ARM_INS_QADD16,
ARM_INS_QADD8,
ARM_INS_QASX,
ARM_INS_QDADD,
ARM_INS_QDSUB,
ARM_INS_QSAX,
ARM_INS_QSUB,
ARM_INS_QSUB16,
ARM_INS_QSUB8,
ARM_INS_RBIT,
ARM_INS_REV,
ARM_INS_REV16,
ARM_INS_REVSH,
ARM_INS_RFEDA,
ARM_INS_RFEDB,
ARM_INS_RFEIA,
ARM_INS_RFEIB,
ARM_INS_RSB,
ARM_INS_RSC,
ARM_INS_SADD16,
ARM_INS_SADD8,
ARM_INS_SASX,
ARM_INS_SBC,
ARM_INS_SBFX,
ARM_INS_SDIV,
ARM_INS_SEL,
ARM_INS_SETEND,
ARM_INS_SHA1C,
ARM_INS_SHA1H,
ARM_INS_SHA1M,
ARM_INS_SHA1P,
ARM_INS_SHA1SU0,
ARM_INS_SHA1SU1,
ARM_INS_SHA256H,
ARM_INS_SHA256H2,
ARM_INS_SHA256SU0,
ARM_INS_SHA256SU1,
ARM_INS_SHADD16,
ARM_INS_SHADD8,
ARM_INS_SHASX,
ARM_INS_SHSAX,
ARM_INS_SHSUB16,
ARM_INS_SHSUB8,
ARM_INS_SMC,
ARM_INS_SMLABB,
ARM_INS_SMLABT,
ARM_INS_SMLAD,
ARM_INS_SMLADX,
ARM_INS_SMLAL,
ARM_INS_SMLALBB,
ARM_INS_SMLALBT,
ARM_INS_SMLALD,
ARM_INS_SMLALDX,
ARM_INS_SMLALTB,
ARM_INS_SMLALTT,
ARM_INS_SMLATB,
ARM_INS_SMLATT,
ARM_INS_SMLAWB,
ARM_INS_SMLAWT,
ARM_INS_SMLSD,
ARM_INS_SMLSDX,
ARM_INS_SMLSLD,
ARM_INS_SMLSLDX,
ARM_INS_SMMLA,
ARM_INS_SMMLAR,
ARM_INS_SMMLS,
ARM_INS_SMMLSR,
ARM_INS_SMMUL,
ARM_INS_SMMULR,
ARM_INS_SMUAD,
ARM_INS_SMUADX,
ARM_INS_SMULBB,
ARM_INS_SMULBT,
ARM_INS_SMULL,
ARM_INS_SMULTB,
ARM_INS_SMULTT,
ARM_INS_SMULWB,
ARM_INS_SMULWT,
ARM_INS_SMUSD,
ARM_INS_SMUSDX,
ARM_INS_SRSDA,
ARM_INS_SRSDB,
ARM_INS_SRSIA,
ARM_INS_SRSIB,
ARM_INS_SSAT,
ARM_INS_SSAT16,
ARM_INS_SSAX,
ARM_INS_SSUB16,
ARM_INS_SSUB8,
ARM_INS_STC2L,
ARM_INS_STC2,
ARM_INS_STCL,
ARM_INS_STC,
ARM_INS_STL,
ARM_INS_STLB,
ARM_INS_STLEX,
ARM_INS_STLEXB,
ARM_INS_STLEXD,
ARM_INS_STLEXH,
ARM_INS_STLH,
ARM_INS_STMDA,
ARM_INS_STMDB,
ARM_INS_STM,
ARM_INS_STMIB,
ARM_INS_STRBT,
ARM_INS_STRB,
ARM_INS_STRD,
ARM_INS_STREX,
ARM_INS_STREXB,
ARM_INS_STREXD,
ARM_INS_STREXH,
ARM_INS_STRH,
ARM_INS_STRHT,
ARM_INS_STRT,
ARM_INS_STR,
ARM_INS_SUB,
ARM_INS_SVC,
ARM_INS_SWP,
ARM_INS_SWPB,
ARM_INS_SXTAB,
ARM_INS_SXTAB16,
ARM_INS_SXTAH,
ARM_INS_SXTB,
ARM_INS_SXTB16,
ARM_INS_SXTH,
ARM_INS_TEQ,
ARM_INS_TRAP,
ARM_INS_TST,
ARM_INS_UADD16,
ARM_INS_UADD8,
ARM_INS_UASX,
ARM_INS_UBFX,
ARM_INS_UDF,
ARM_INS_UDIV,
ARM_INS_UHADD16,
ARM_INS_UHADD8,
ARM_INS_UHASX,
ARM_INS_UHSAX,
ARM_INS_UHSUB16,
ARM_INS_UHSUB8,
ARM_INS_UMAAL,
ARM_INS_UMLAL,
ARM_INS_UMULL,
ARM_INS_UQADD16,
ARM_INS_UQADD8,
ARM_INS_UQASX,
ARM_INS_UQSAX,
ARM_INS_UQSUB16,
ARM_INS_UQSUB8,
ARM_INS_USAD8,
ARM_INS_USADA8,
ARM_INS_USAT,
ARM_INS_USAT16,
ARM_INS_USAX,
ARM_INS_USUB16,
ARM_INS_USUB8,
ARM_INS_UXTAB,
ARM_INS_UXTAB16,
ARM_INS_UXTAH,
ARM_INS_UXTB,
ARM_INS_UXTB16,
ARM_INS_UXTH,
ARM_INS_VABAL,
ARM_INS_VABA,
ARM_INS_VABDL,
ARM_INS_VABD,
ARM_INS_VABS,
ARM_INS_VACGE,
ARM_INS_VACGT,
ARM_INS_VADD,
ARM_INS_VADDHN,
ARM_INS_VADDL,
ARM_INS_VADDW,
ARM_INS_VAND,
ARM_INS_VBIC,
ARM_INS_VBIF,
ARM_INS_VBIT,
ARM_INS_VBSL,
ARM_INS_VCEQ,
ARM_INS_VCGE,
ARM_INS_VCGT,
ARM_INS_VCLE,
ARM_INS_VCLS,
ARM_INS_VCLT,
ARM_INS_VCLZ,
ARM_INS_VCMP,
ARM_INS_VCMPE,
ARM_INS_VCNT,
ARM_INS_VCVTA,
ARM_INS_VCVTB,
ARM_INS_VCVT,
ARM_INS_VCVTM,
ARM_INS_VCVTN,
ARM_INS_VCVTP,
ARM_INS_VCVTT,
ARM_INS_VDIV,
ARM_INS_VDUP,
ARM_INS_VEOR,
ARM_INS_VEXT,
ARM_INS_VFMA,
ARM_INS_VFMS,
ARM_INS_VFNMA,
ARM_INS_VFNMS,
ARM_INS_VHADD,
ARM_INS_VHSUB,
ARM_INS_VLD1,
ARM_INS_VLD2,
ARM_INS_VLD3,
ARM_INS_VLD4,
ARM_INS_VLDMDB,
ARM_INS_VLDMIA,
ARM_INS_VLDR,
ARM_INS_VMAXNM,
ARM_INS_VMAX,
ARM_INS_VMINNM,
ARM_INS_VMIN,
ARM_INS_VMLA,
ARM_INS_VMLAL,
ARM_INS_VMLS,
ARM_INS_VMLSL,
ARM_INS_VMOVL,
ARM_INS_VMOVN,
ARM_INS_VMSR,
ARM_INS_VMUL,
ARM_INS_VMULL,
ARM_INS_VMVN,
ARM_INS_VNEG,
ARM_INS_VNMLA,
ARM_INS_VNMLS,
ARM_INS_VNMUL,
ARM_INS_VORN,
ARM_INS_VORR,
ARM_INS_VPADAL,
ARM_INS_VPADDL,
ARM_INS_VPADD,
ARM_INS_VPMAX,
ARM_INS_VPMIN,
ARM_INS_VQABS,
ARM_INS_VQADD,
ARM_INS_VQDMLAL,
ARM_INS_VQDMLSL,
ARM_INS_VQDMULH,
ARM_INS_VQDMULL,
ARM_INS_VQMOVUN,
ARM_INS_VQMOVN,
ARM_INS_VQNEG,
ARM_INS_VQRDMULH,
ARM_INS_VQRSHL,
ARM_INS_VQRSHRN,
ARM_INS_VQRSHRUN,
ARM_INS_VQSHL,
ARM_INS_VQSHLU,
ARM_INS_VQSHRN,
ARM_INS_VQSHRUN,
ARM_INS_VQSUB,
ARM_INS_VRADDHN,
ARM_INS_VRECPE,
ARM_INS_VRECPS,
ARM_INS_VREV16,
ARM_INS_VREV32,
ARM_INS_VREV64,
ARM_INS_VRHADD,
ARM_INS_VRINTA,
ARM_INS_VRINTM,
ARM_INS_VRINTN,
ARM_INS_VRINTP,
ARM_INS_VRINTR,
ARM_INS_VRINTX,
ARM_INS_VRINTZ,
ARM_INS_VRSHL,
ARM_INS_VRSHRN,
ARM_INS_VRSHR,
ARM_INS_VRSQRTE,
ARM_INS_VRSQRTS,
ARM_INS_VRSRA,
ARM_INS_VRSUBHN,
ARM_INS_VSELEQ,
ARM_INS_VSELGE,
ARM_INS_VSELGT,
ARM_INS_VSELVS,
ARM_INS_VSHLL,
ARM_INS_VSHL,
ARM_INS_VSHRN,
ARM_INS_VSHR,
ARM_INS_VSLI,
ARM_INS_VSQRT,
ARM_INS_VSRA,
ARM_INS_VSRI,
ARM_INS_VST1,
ARM_INS_VST2,
ARM_INS_VST3,
ARM_INS_VST4,
ARM_INS_VSTMDB,
ARM_INS_VSTMIA,
ARM_INS_VSTR,
ARM_INS_VSUB,
ARM_INS_VSUBHN,
ARM_INS_VSUBL,
ARM_INS_VSUBW,
ARM_INS_VSWP,
ARM_INS_VTBL,
ARM_INS_VTBX,
ARM_INS_VCVTR,
ARM_INS_VTRN,
ARM_INS_VTST,
ARM_INS_VUZP,
ARM_INS_VZIP,
ARM_INS_ADDW,
ARM_INS_ASR,
ARM_INS_DCPS1,
ARM_INS_DCPS2,
ARM_INS_DCPS3,
ARM_INS_IT,
ARM_INS_LSL,
ARM_INS_LSR,
ARM_INS_ORN,
ARM_INS_ROR,
ARM_INS_RRX,
ARM_INS_SUBW,
ARM_INS_TBB,
ARM_INS_TBH,
ARM_INS_CBNZ,
ARM_INS_CBZ,
ARM_INS_POP,
ARM_INS_PUSH,
// special instructions
ARM_INS_NOP,
ARM_INS_YIELD,
ARM_INS_WFE,
ARM_INS_WFI,
ARM_INS_SEV,
ARM_INS_SEVL,
ARM_INS_VPUSH,
ARM_INS_VPOP,
ARM_INS_ENDING, // <-- mark the end of the list of instructions
} arm_insn;
//> Group of ARM instructions
typedef enum arm_insn_group
{
ARM_GRP_INVALID = 0, // = CS_GRP_INVALID
//> Generic groups
// all jump instructions (conditional+direct+indirect jumps)
ARM_GRP_JUMP, // = CS_GRP_JUMP
ARM_GRP_CALL, // = CS_GRP_CALL
ARM_GRP_INT = 4, // = CS_GRP_INT
ARM_GRP_PRIVILEGE = 6, // = CS_GRP_PRIVILEGE
//> Architecture-specific groups
ARM_GRP_CRYPTO = 128,
ARM_GRP_DATABARRIER,
ARM_GRP_DIVIDE,
ARM_GRP_FPARMV8,
ARM_GRP_MULTPRO,
ARM_GRP_NEON,
ARM_GRP_T2EXTRACTPACK,
ARM_GRP_THUMB2DSP,
ARM_GRP_TRUSTZONE,
ARM_GRP_V4T,
ARM_GRP_V5T,
ARM_GRP_V5TE,
ARM_GRP_V6,
ARM_GRP_V6T2,
ARM_GRP_V7,
ARM_GRP_V8,
ARM_GRP_VFP2,
ARM_GRP_VFP3,
ARM_GRP_VFP4,
ARM_GRP_ARM,
ARM_GRP_MCLASS,
ARM_GRP_NOTMCLASS,
ARM_GRP_THUMB,
ARM_GRP_THUMB1ONLY,
ARM_GRP_THUMB2,
ARM_GRP_PREV8,
ARM_GRP_FPVMLX,
ARM_GRP_MULOPS,
ARM_GRP_CRC,
ARM_GRP_DPVFP,
ARM_GRP_V6M,
ARM_GRP_VIRTUALIZATION,
ARM_GRP_ENDING,
} arm_insn_group;
#ifdef __cplusplus
}
#endif
#endif
```
|
Four Depressive Seasons is the debut album by Danish death metal band Illdisposed.
Track listing
Forbidden Summer Poetry - 3:55
Reversed - 5:08
Weeping Souls of Autumn Desires - 5:53
Life Equals Zero (A Love Song) - 4:33
A Deathwork Orange... - 7:41
...The Winter of Our Discontempt - 5:36
Wardance of the Technocracy - 5:04
Inherit the Wind - 4:52
With the Lost Souls on Our Side - 4:40
Personnel
Bo Summer - vocals
Lasse Bak - guitar
Ronnie Bak - bass
Michael Enevoldsen - drums
Additional lead guitar by Hans Wagner, all lyrics written by Bo Summer, all music written by Illdisposed.
References
Illdisposed albums
1993 albums
Diehard Music albums
|
```html
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "path_to_url">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Class template day_clock</title>
<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../../date_time/doxy.html#header.boost.date_time.date_clock_device_hpp" title="Header <boost/date_time/date_clock_device.hpp>">
<link rel="prev" href="date.html" title="Class template date">
<link rel="next" href="date_duration.html" title="Class template date_duration">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
<td align="center"><a href="../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="path_to_url">People</a></td>
<td align="center"><a href="path_to_url">FAQ</a></td>
<td align="center"><a href="../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="date.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../date_time/doxy.html#header.boost.date_time.date_clock_device_hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="date_duration.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="refentry">
<a name="boost.date_time.day_clock"></a><div class="titlepage"></div>
<div class="refnamediv">
<h2><span class="refentrytitle">Class template day_clock</span></h2>
<p>boost::date_time::day_clock — A clock providing day level services based on C time_t capabilities. </p>
</div>
<h2 xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" class="refsynopsisdiv-title">Synopsis</h2>
<div xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: <<a class="link" href="../../date_time/doxy.html#header.boost.date_time.date_clock_device_hpp" title="Header <boost/date_time/date_clock_device.hpp>">boost/date_time/date_clock_device.hpp</a>>
</span><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> date_type<span class="special">></span>
<span class="keyword">class</span> <a class="link" href="day_clock.html" title="Class template day_clock">day_clock</a> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="comment">// types</span>
<span class="keyword">typedef</span> <span class="identifier">date_type</span><span class="special">::</span><span class="identifier">ymd_type</span> <a name="boost.date_time.day_clock.ymd_type"></a><span class="identifier">ymd_type</span><span class="special">;</span>
<span class="comment">// <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_5-bb">public static functions</a></span>
<span class="keyword">static</span> <span class="identifier">date_type</span> <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_5_1-bb"><span class="identifier">local_day</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">static</span> <span class="identifier">date_type</span><span class="special">::</span><span class="identifier">ymd_type</span> <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_5_2-bb"><span class="identifier">local_day_ymd</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">static</span> <span class="identifier">date_type</span><span class="special">::</span><span class="identifier">ymd_type</span> <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_5_3-bb"><span class="identifier">universal_day_ymd</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">static</span> <span class="identifier">date_type</span> <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_5_4-bb"><span class="identifier">universal_day</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_6-bb">private static functions</a></span>
<span class="keyword">static</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">*</span> <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_6_1-bb"><span class="identifier">get_local_time</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">&</span><span class="special">)</span><span class="special">;</span>
<span class="keyword">static</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">*</span> <a class="link" href="day_clock.html#id-1_3_12_15_3_8_1_1_1_6_2-bb"><span class="identifier">get_universal_time</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">&</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span><span class="special">;</span></pre></div>
<div class="refsect1">
<a name="id-1.3.12.15.3.8.3.4"></a><h2>Description</h2>
<p>This clock uses Posix interfaces as its implementation and hence uses the timezone settings of the operating system. Incorrect user settings will result in incorrect results for the calls to local_day. </p>
<div class="refsect2">
<a name="id-1.3.12.15.3.8.3.4.3"></a><h3>
<a name="id-1_3_12_15_3_8_1_1_1_5-bb"></a><code class="computeroutput">day_clock</code> public static functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
<pre class="literallayout"><span class="keyword">static</span> <span class="identifier">date_type</span> <a name="id-1_3_12_15_3_8_1_1_1_5_1-bb"></a><span class="identifier">local_day</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the local day as a date type. </li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">static</span> <span class="identifier">date_type</span><span class="special">::</span><span class="identifier">ymd_type</span> <a name="id-1_3_12_15_3_8_1_1_1_5_2-bb"></a><span class="identifier">local_day_ymd</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the local day as a ymd_type. </li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">static</span> <span class="identifier">date_type</span><span class="special">::</span><span class="identifier">ymd_type</span> <a name="id-1_3_12_15_3_8_1_1_1_5_3-bb"></a><span class="identifier">universal_day_ymd</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the current day in universal date as a ymd_type. </li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">static</span> <span class="identifier">date_type</span> <a name="id-1_3_12_15_3_8_1_1_1_5_4-bb"></a><span class="identifier">universal_day</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>Get the UTC day as a date type. </li>
</ol></div>
</div>
<div class="refsect2">
<a name="id-1.3.12.15.3.8.3.4.4"></a><h3>
<a name="id-1_3_12_15_3_8_1_1_1_6-bb"></a><code class="computeroutput">day_clock</code> private static functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem"><pre class="literallayout"><span class="keyword">static</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">*</span> <a name="id-1_3_12_15_3_8_1_1_1_6_1-bb"></a><span class="identifier">get_local_time</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">&</span> result<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">static</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">*</span> <a name="id-1_3_12_15_3_8_1_1_1_6_2-bb"></a><span class="identifier">get_universal_time</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tm</span> <span class="special">&</span> result<span class="special">)</span><span class="special">;</span></pre></li>
</ol></div>
</div>
</div>
</div>
<table xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<code class="filename">LICENSE_1_0.txt</code> or copy at <a href="path_to_url" target="_top">path_to_url
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="date.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../date_time/doxy.html#header.boost.date_time.date_clock_device_hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="date_duration.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
```
|
```c++
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// test_strong_typedef.cpp
// Use, modification and distribution is subject to the Boost Software
// path_to_url
// should pass compilation
#include <stdlib.h> // EXIT_SUCCESS
#include <boost/config.hpp>
#include <boost/serialization/strong_typedef.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/has_nothrow_assign.hpp>
#include <boost/type_traits/has_nothrow_constructor.hpp>
#include <boost/type_traits/has_nothrow_copy.hpp>
///////////////////////////////////////////////////////////////////////
// Define a strong typedef for int.
// The new type should be nothrow constructible and assignable.
BOOST_STRONG_TYPEDEF(int, strong_int)
#ifndef BOOST_HAS_NOTHROW_CONSTRUCTOR
BOOST_STATIC_ASSERT(boost::has_nothrow_default_constructor<strong_int>::value);
BOOST_STATIC_ASSERT(boost::has_nothrow_copy_constructor<strong_int>::value);
BOOST_STATIC_ASSERT(boost::has_nothrow_assign<strong_int>::value);
#endif
///////////////////////////////////////////////////////////////////////
// strong_int can now be placed in another type, which can also be
// nothrow constructible and assignable.
struct type1
{
long some_long;
strong_int sint;
};
#ifndef BOOST_HAS_NOTHROW_CONSTRUCTOR
BOOST_STATIC_ASSERT(boost::has_nothrow_default_constructor<type1>::value);
BOOST_STATIC_ASSERT(boost::has_nothrow_copy_constructor<type1>::value);
BOOST_STATIC_ASSERT(boost::has_nothrow_assign<type1>::value);
#endif
///////////////////////////////////////////////////////////////////////
// Now define a type that throws, and a strong_typedef for it
// The strong_typedef should also not have nothrow construction/assign.
struct not_noexcept
{
not_noexcept() {}
not_noexcept(not_noexcept const&) {}
not_noexcept& operator=(not_noexcept const&) {return *this;}
bool operator==(not_noexcept const&) const {return false;}
bool operator<(not_noexcept const&) const {return false;}
};
BOOST_STRONG_TYPEDEF(not_noexcept, strong_not_noexcept)
#ifndef BOOST_HAS_NOTHROW_CONSTRUCTOR
BOOST_STATIC_ASSERT(! boost::has_nothrow_default_constructor<strong_not_noexcept>::value);
BOOST_STATIC_ASSERT(! boost::has_nothrow_copy_constructor<strong_not_noexcept>::value);
BOOST_STATIC_ASSERT(! boost::has_nothrow_assign<strong_not_noexcept>::value);
#endif
int main()
{
return EXIT_SUCCESS;
}
```
|
Ayyanar Falls is located west of Rajapalayam, a city and a municipality in Virudhunagar District in the Indian State of Tamil Nadu. It is situated in the Western Ghats, which gets its water source mainly during the north east monsoon rain. The water from the falls is mainly used for drinking purposes by the people living in Rajapalayam.
The falls is one of the main attractions of Rajapalayam, and is a famous tourist spot for the people living in East part of Virudhunagar District, especially Srivilliputtur and Sivakasi. It provides good opportunity for woodland mountain climbing. A dam is situated on the way to Ayyanar Falls which provides water for the whole city.
The falls also attracts wildlife photographers who are interested in the bio-diversity of the Western Ghats. The ayyanar falls also serves as the source of water for the animals like Monkey, Elephant, Deer and Buffalo living in the forests of Western ghats.
The name Ayyanar is given to these falls because there is a small forest temple named Ayyanar Temple beside the falls.
Neer Katha Aiyyanar temple
The Neer Katha Ayyanar temple is the main reason for the name of the falls. The temple is situated at the foothills of Western Ghats where two rivers, Palaru and Neeraru meet. It is more than 500 years old. Devotees approach Ayyanar for solutions to family problems. Realizing their expectations, devotees perform abishek to Ayyanar, feed the poor and contribute what they can to the temple.
Floods
Sudden floods in the rainy season sometimes result in people being stuck in the temple. Fire fighters from Rajapalayam rescue the people and help them to cross the river safely. Visitors are not allowed at the falls during heavy rain.
6th Mile Dam reservoir
The 6th Mile Dam reservoir is supplied by falls. The reservoir is from Rajapalayam and is the main water source for the city and neighbouring villages, and for irrigation. It also a major tourist attraction. A water treatment plant is situated near the water reservoir. Many Tamil films such as Kutti Puli are shot near the dam.
Tourism
Ayyanar Falls are among many cascades in southern Tamil Nadu. Other tourist destinations in the area are Ayyanar Kovil, a dam near the falls, Srivilliputtur, Ayyanar Koil Forest area, Sri Vallakattu Karuppasamy Kovil, Sanjeevi Hills and Shenbagathoppu Grizzled Squirrel Wildlife Sanctuary. Tourism is the main source of livelihood for people in neighbouring villages. The nearest airport to the falls is at Madurai.
References
External links
Rajapalayam
Rajapalayam.Org - Ayyanar Falls
Waterfalls of Tamil Nadu
|
The grey-breasted laughingthrush or Kerala laughingthrush has been split into the following species:
Palani laughingthrush, Montecincla fairbanki
Ashambu laughingthrush, Montecincla meridionalis
Birds by common name
|
```c++
#include "search_context.h"
#include "attributevector.h"
#include "attributeiterators.hpp"
#include "ipostinglistsearchcontext.h"
#include <vespa/searchlib/queryeval/emptysearch.h>
using search::queryeval::SearchIterator;
namespace search::attribute {
HitEstimate
SearchContext::calc_hit_estimate() const
{
if (_plsc != nullptr) {
return _plsc->calc_hit_estimate();
}
return HitEstimate::unknown(std::max(uint64_t(_attr.getNumDocs()), _attr.getStatus().getNumValues()));
}
std::unique_ptr<SearchIterator>
SearchContext::createIterator(fef::TermFieldMatchData* matchData, bool strict)
{
if (_plsc != nullptr) {
auto res = _plsc->createPostingIterator(matchData, strict);
if (res) {
return res;
}
}
return createFilterIterator(matchData, strict);
}
std::unique_ptr<SearchIterator>
SearchContext::createFilterIterator(fef::TermFieldMatchData* matchData, bool strict)
{
if (!valid()) {
return std::make_unique<queryeval::EmptySearch>();
}
if (getIsFilter()) {
return (strict ?
std::make_unique<FilterAttributeIteratorStrict<SearchContext>>(*this, matchData) :
std::make_unique<FilterAttributeIteratorT<SearchContext>>(*this, matchData));
}
return (strict ?
std::make_unique<AttributeIteratorStrict<SearchContext>>(*this, matchData) :
std::make_unique<AttributeIteratorT<SearchContext>>(*this, matchData));
}
void
SearchContext::fetchPostings(const queryeval::ExecuteInfo& execInfo, bool strict)
{
if (_plsc != nullptr) {
_plsc->fetchPostings(execInfo, strict);
}
}
const std::string&
SearchContext::attributeName() const
{
return _attr.getName();
}
bool
SearchContext::getIsFilter() const
{
return _attr.getIsFilter();
}
}
```
|
```swift
/*
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 the copyright holder(s) nor the names of any contributors
may be used to endorse or promote products derived from this software without
specific prior written permission. No license is granted to the trademarks of
the copyright holders even if such marks are included in this software.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
import UIKit
extension Double {
var normalized: Double {
return max(0, min(self, 1))
}
}
extension CGFloat {
/// Scaled value for the current size category.
func scaled() -> CGFloat {
UIFontMetrics.default.scaledValue(for: self)
}
/// The value between `self` and `end` with distance of `factor` between 0 and 1.
func interpolated(to end: CGFloat, factor: CGFloat) -> CGFloat {
precondition(factor >= 0 && factor <= 1, "Factor should be in range [0, 1]")
return (self + (factor * (end - self)))
.clamped(to: (self...end))
}
func clamped(to range: ClosedRange<CGFloat>) -> CGFloat {
return Swift.max(Swift.min(self, range.upperBound), range.lowerBound)
}
}
```
|
Northwestern Bell Telephone Company served the states of the upper Midwest opposite the Southwestern Bell area, including Iowa, Minnesota, South Dakota, North Dakota, and Nebraska.
History
Early beginnings
It has never been definitively established where Northwestern Bell's earliest roots lie. The earliest record of telephones in the Northwestern Bell service area was a two-telephone intercom circuit used by a Little Falls, Minnesota, druggist and his clerk in 1876. A Bell-licensed exchange is believed to have opened in Deadwood, South Dakota, between March and August 1878, just two years after Alexander Graham Bell invented the telephone, and several months before President Rutherford B. Hayes could use his phone in a little wooden booth outside of his office in the White House.
The earliest documented telephone exchange in Northwestern Bell territory was opened by the Western Union Company in Keokuk, Iowa, on September 1, 1878. Using superior equipment designed by Thomas Edison and Elisha Gray, Western Union was in a competitive shoot-out with local licensee of the National Bell Telephone Company in Boston. On November 10, 1879, Western Union settled a Bell patent infringement suit by getting completely out of the phone business and selling all of its exchanges, including the Keokuk exchange, to the Bell Company.
In the fall of 1878, the Northwestern Telephone Company opened an "experimental" exchange in Minneapolis-located in City Hall, it served the city government as well as the Nicollet Hotel and Pillsbury Mills*. This exchange was the forerunner of the Bell-licensed Northwestern Telephone Exchange Company which was incorporated on December 10, 1878.
When the Northwestern Telephone Exchange Company was organized, it had authorized capital stock of $10,000.
On July 11, 1939, Northwestern Bell Telephone established dial service in Fargo, North Dakota.
Building Northwestern Bell
Telephone companies in the Northwestern Bell Group included the Tri-State Telephone Company, the Dakota Central Telephone Company, the Iowa Telephone Company, the Nebraska Telephone Company and the Northwestern Telephone Exchange.
Casper E. Yost served as the president of all the companies. It was a confusing arrangement to regulators, employees and even to the parent company, AT&T. In a letter to AT&T, Yost explained that when he was answering a question, making a proposal or discussing a problem in his correspondence with AT&T, he would use the letterhead of the particular company to which the question, problem or proposal related. One problem with this arrangement, especially for local telephone staffers and historians, is that the carbons of Yost's letters contain no letterheads.
Things became less confusing when the Tri-State and Dakota Central companies were folded into the Northwestern Telephone Exchange Company. In 1909, a single general office staff for the Iowa, Nebraska and Exchange companies was established in Omaha.
On December 10, 1920, Iowa Telephone changed its name to Northwestern Bell Telephone Company. In January, 1921, the Nebraska and Northwestern Telephone Exchange companies were merged into the new company. While the new company was incorporated in Iowa, its headquarters remained in Omaha.
Sale of telephone lines
In 1976, Northwestern Bell sold access lines in the Midland, Philip, Martin, White River, Milesville, and Hayes exchanges to Golden West Telephone, a small telephone cooperative in South Dakota.
Headquarters
The Northwestern Bell headquarters, now the AT&T Building (owned by CenturyLink), was located at 118 South 19th Street in Omaha, Nebraska.
Name usage
The Northwestern Bell name is still licensed for use today on telephone equipment produced by Unical Enterprises; otherwise, the NWBT name has disappeared. Dex Media white pages lists a customer service number under the Northwestern Bell name (which connects to Qwest). Additionally, the NorthWesternBell.com domain is still active and rolls over to the CenturyLink webpage.
References
Bell System
Lumen Technologies
Economy of the Midwestern United States
Defunct telecommunications companies of the United States
American companies established in 1896
Telecommunications companies established in 1896
Communications in Nebraska
Communications in Iowa
Communications in Minnesota
Communications in South Dakota
Communications in North Dakota
American companies disestablished in 1991
Telecommunications companies disestablished in 1991
|
```javascript
/*
* All rights reserved.
*
* This source code is licensed under the license found in the LICENSE file in
* the root directory of this source tree.
*/
import React from 'react';
import Checkbox from 'components/Checkbox/Checkbox.react';
export const component = Checkbox;
export const demos = [
{
render: () => (
<div>
<div>
<Checkbox label="unchecked" />
</div>
<div>
<Checkbox checked={true} label="checked" />
</div>
<div>
<Checkbox indeterminate={true} label="indeterminate" />
</div>
</div>
),
},
];
```
|
Ernest Hamlin Baker (1889–1975) was an American artist and illustrator from Poughkeepsie, New York. He illustrated more than 300 covers for Time magazine. He also made posters for the American Legion. He drew political cartoons for Poughkeepsie's Evening Star newspaper. His work was part of the painting event in the art competition at the 1932 Summer Olympics.
He graduated from Colgate University.
References
External links
Examples of Baker's magazine covers
Pettaquamscutt Historical Society Mural – Kingston RI at Living New Deal
American illustrators
1889 births
1975 deaths
Magazine illustrators
Section of Painting and Sculpture artists
Olympic competitors in art competitions
|
```smalltalk
using System;
namespace Xamarin.Forms.Performance.Integration
{
public class Item
{
public string Id { get; set; }
public string Text { get; set; }
public string Description { get; set; }
}
}
```
|
```html
<!--
DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
This code is free software; you can redistribute it and/or modify it
published by the Free Software Foundation. Oracle designates this
particular file as subject to the "Classpath" exception as provided
by Oracle in the LICENSE file that accompanied this code.
This code is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
version 2 for more details (a copy is included in the LICENSE file that
accompanied this code).
2 along with this work; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
or visit www.oracle.com if you need additional information or have any
questions.
-->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
Gives you a module suite with
two modules, one providing a
pluggable view and the other
plugging a subtab into it.
</body>
</html>
```
|
```python
#
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# ===========================================================================
#
# This file is adapted from
# path_to_url
#
# Apache 2.0 license
# path_to_url
import os
import torch
from typing import List, Optional, Union, Dict
from sentencepiece import SentencePieceProcessor
from transformers import PreTrainedTokenizer
from transformers.utils import logging, PaddingStrategy
from transformers.tokenization_utils_base import EncodedInput, BatchEncoding
class SPTokenizer:
def __init__(self, model_path: str):
# reload tokenizer
assert os.path.isfile(model_path), model_path
self.sp_model = SentencePieceProcessor(model_file=model_path)
# BOS / EOS token IDs
self.n_words: int = self.sp_model.vocab_size()
self.bos_id: int = self.sp_model.bos_id()
self.eos_id: int = self.sp_model.eos_id()
self.pad_id: int = self.sp_model.unk_id()
assert self.sp_model.vocab_size() == self.sp_model.get_piece_size()
special_tokens = ["[MASK]", "[gMASK]", "[sMASK]", "sop", "eop"]
self.special_tokens = {}
self.index_special_tokens = {}
for token in special_tokens:
self.special_tokens[token] = self.n_words
self.index_special_tokens[self.n_words] = token
self.n_words += 1
def tokenize(self, s: str):
return self.sp_model.EncodeAsPieces(s)
def encode(self, s: str, bos: bool = False, eos: bool = False) -> List[int]:
assert type(s) is str
t = self.sp_model.encode(s)
if bos:
t = [self.bos_id] + t
if eos:
t = t + [self.eos_id]
return t
def decode(self, t: List[int]) -> str:
return self.sp_model.decode(t)
def decode_tokens(self, tokens: List[str]) -> str:
text = self.sp_model.DecodePieces(tokens)
return text
def convert_token_to_id(self, token):
""" Converts a token (str) in an id using the vocab. """
if token in self.special_tokens:
return self.special_tokens[token]
return self.sp_model.PieceToId(token)
def convert_id_to_token(self, index):
"""Converts an index (integer) in a token (str) using the vocab."""
if index in self.index_special_tokens or index in [self.eos_id, self.bos_id, self.pad_id] or index < 0:
return ""
return self.sp_model.IdToPiece(index)
class ChatGLMTokenizer(PreTrainedTokenizer):
vocab_files_names = {"vocab_file": "tokenizer.model"}
model_input_names = ["input_ids", "attention_mask", "position_ids"]
def __init__(self, vocab_file, padding_side="left", clean_up_tokenization_spaces=False, **kwargs):
self.tokenizer = SPTokenizer(vocab_file)
super().__init__(padding_side=padding_side, clean_up_tokenization_spaces=clean_up_tokenization_spaces, **kwargs)
self.name = "GLMTokenizer"
self.vocab_file = vocab_file
self.special_tokens = {
"<bos>": self.tokenizer.bos_id,
"<eos>": self.tokenizer.eos_id,
"<pad>": self.tokenizer.pad_id
}
def get_command(self, token):
if token in self.special_tokens:
return self.special_tokens[token]
assert token in self.tokenizer.special_tokens, f"{token} is not a special token for {self.name}"
return self.tokenizer.special_tokens[token]
@property
def unk_token(self) -> str:
return "<unk>"
@property
def pad_token(self) -> str:
return "<unk>"
@property
def pad_token_id(self):
return self.get_command("<pad>")
@property
def eos_token(self) -> str:
return "</s>"
@property
def eos_token_id(self):
return self.get_command("<eos>")
@property
def vocab_size(self):
return self.tokenizer.n_words
def get_vocab(self):
""" Returns vocab as a dict """
vocab = {self._convert_id_to_token(i): i for i in range(self.vocab_size)}
vocab.update(self.added_tokens_encoder)
return vocab
def _tokenize(self, text, **kwargs):
return self.tokenizer.tokenize(text)
def _convert_token_to_id(self, token):
""" Converts a token (str) in an id using the vocab. """
return self.tokenizer.convert_token_to_id(token)
def _convert_id_to_token(self, index):
"""Converts an index (integer) in a token (str) using the vocab."""
return self.tokenizer.convert_id_to_token(index)
def convert_tokens_to_string(self, tokens: List[str]) -> str:
return self.tokenizer.decode_tokens(tokens)
def save_vocabulary(self, save_directory, filename_prefix=None):
"""
Save the vocabulary and special tokens file to a directory.
Args:
save_directory (`str`):
The directory in which to save the vocabulary.
filename_prefix (`str`, *optional*):
An optional prefix to add to the named of the saved files.
Returns:
`Tuple(str)`: Paths to the files saved.
"""
if os.path.isdir(save_directory):
vocab_file = os.path.join(
save_directory, self.vocab_files_names["vocab_file"]
)
else:
vocab_file = save_directory
with open(self.vocab_file, 'rb') as fin:
proto_str = fin.read()
with open(vocab_file, "wb") as writer:
writer.write(proto_str)
return (vocab_file,)
def get_prefix_tokens(self):
prefix_tokens = [self.get_command("[gMASK]"), self.get_command("sop")]
return prefix_tokens
def build_prompt(self, query, history=None):
if history is None:
history = []
prompt = ""
for i, (old_query, response) in enumerate(history):
prompt += "[Round {}]\n\n{}\n\n{}\n\n".format(i + 1, old_query, response)
prompt += "[Round {}]\n\n{}\n\n".format(len(history) + 1, query)
return prompt
def build_inputs_with_special_tokens(
self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
) -> List[int]:
"""
Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
adding special tokens. A BERT sequence has the following format:
- single sequence: `[CLS] X [SEP]`
- pair of sequences: `[CLS] A [SEP] B [SEP]`
Args:
token_ids_0 (`List[int]`):
List of IDs to which the special tokens will be added.
token_ids_1 (`List[int]`, *optional*):
Optional second list of IDs for sequence pairs.
Returns:
`List[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens.
"""
prefix_tokens = self.get_prefix_tokens()
token_ids_0 = prefix_tokens + token_ids_0
if token_ids_1 is not None:
token_ids_0 = token_ids_0 + token_ids_1 + [self.get_command("<eos>")]
return token_ids_0
def _pad(
self,
encoded_inputs: Union[Dict[str, EncodedInput], BatchEncoding],
max_length: Optional[int] = None,
padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD,
pad_to_multiple_of: Optional[int] = None,
return_attention_mask: Optional[bool] = None,
) -> dict:
"""
Pad encoded inputs (on left/right and up to predefined length or max length in the batch)
Args:
encoded_inputs:
Dictionary of tokenized inputs (`List[int]`) or batch of tokenized inputs (`List[List[int]]`).
max_length: maximum length of the returned list and optionally padding length (see below).
Will truncate by taking into account the special tokens.
padding_strategy: PaddingStrategy to use for padding.
- PaddingStrategy.LONGEST Pad to the longest sequence in the batch
- PaddingStrategy.MAX_LENGTH: Pad to the max length (default)
- PaddingStrategy.DO_NOT_PAD: Do not pad
The tokenizer padding sides are defined in self.padding_side:
- 'left': pads on the left of the sequences
- 'right': pads on the right of the sequences
pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value.
This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability
`>= 7.5` (Volta).
return_attention_mask:
(optional) Set to False to avoid returning attention mask (default: set to model specifics)
"""
# Load from model defaults
# assert self.padding_side == "left"
required_input = encoded_inputs[self.model_input_names[0]]
seq_length = len(required_input)
if padding_strategy == PaddingStrategy.LONGEST:
max_length = len(required_input)
if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of
needs_to_be_padded = padding_strategy != PaddingStrategy.DO_NOT_PAD and len(required_input) != max_length
# Initialize attention mask if not present.
if "attention_mask" not in encoded_inputs:
encoded_inputs["attention_mask"] = [1] * seq_length
if "position_ids" not in encoded_inputs:
encoded_inputs["position_ids"] = list(range(seq_length))
if needs_to_be_padded:
difference = max_length - len(required_input)
if self.padding_side == "left":
if "attention_mask" in encoded_inputs:
encoded_inputs["attention_mask"] = [0] * difference + encoded_inputs["attention_mask"]
if "position_ids" in encoded_inputs:
encoded_inputs["position_ids"] = [0] * difference + encoded_inputs["position_ids"]
encoded_inputs[self.model_input_names[0]] = [self.pad_token_id] * difference + required_input
else:
if "attention_mask" in encoded_inputs:
encoded_inputs["attention_mask"] = encoded_inputs["attention_mask"] + [0] * difference
if "position_ids" in encoded_inputs:
encoded_inputs["position_ids"] = encoded_inputs["position_ids"] + [0] * difference
encoded_inputs[self.model_input_names[0]] = required_input + [self.pad_token_id] * difference
return encoded_inputs
```
|
Marquavis Goolsby (born July 29, 1992), better known by his stage name Dae Dae, is an American rapper from Atlanta, Georgia. He is known for his debut single "Wat U Mean (Aye, Aye, Aye)."
Early life
Dae Dae grew up in Atlanta's Boulevard Fourth Ward. He found early interest in music at about 8 years old, when his estranged father, John Burton, bought him Bow Wow and Lil Romeo CDs. At age fourteen, Dae Dae dropped out of school and became a father for the first time. Still interested in music and rapping, Dae Dae's father converted a room in their home to a recording studio for him. Shortly after, police arrested his father for having drugs in the home, and confiscated the studio equipment when his father was unable to provide receipts for their purchase. Left with nothing, Dae Dae quickly got a job doing concrete and flooring work, saving all of his earned money to record at a local studio and participate in weekly open mic nights. He eventually met his manager Anthem, who knew Atlanta based producer Nitti, and was offered a record deal from Nitti Beatz Recordings.
Career
2015–present
Dae Dae released his first single, "Wat U Mean (Aye, Aye, Aye)" in 2015. He wrote the song while at work, freestyling lines in his head and writing them in his iPhone before calling his producer and recording the song later that day. After signing with 300 Entertainment in 2016, Dae Dae released a mixtape titled 4 Reasons, which features cameos from artists such as Rich Homie Quan. In February 2016, Dae Dae released the single "Spend It", which was later remixed by Lil Wayne and 2 Chainz. The song was produced by Young Trill Beatz. A music video for "Spend It" was released in November 2016. Dae Dae joined Young Thug's May 2016 Hi-Tunes tour throughout the United States along with TM88 and Rich The Kid. An official remix of "Wat U Mean" featuring Lil Yachty was released in July 2016. Dae Dae's third single "Dej Loaf" was released in August 2016. In January 2017, he released the single "Dem Days" and was named one of FACT Magazine's 10 Rappers to Watch in 2017.
Success of "Wat U Mean"
The popularity of Dae Dae's "Wat U Mean" had been steadily increasing since its 2015 release, especially after being remixed by Young Dro. The song was the top song discovered via Shazam in Atlanta in early 2016. In May 2016, a video of a dancer named Matthew King dancing to the song went viral via Twitter, further increasing its exposure and popularity. During the week of June 11, 2016, it was featured on Billboard's Twitter Emerging Artists chart at No. 24. He performed the song live at the 2016 BET Hip Hop Awards.
Legal issues
In June 2021, Dae Dae was arrested for stabbing a 17-year-old Dunkin' Donuts employee in December 2020, because the store was out of what he wanted.
Discography
Mixtapes
4 Reasons (2016)
The DefAnition (with London on da Track) (2016)
5 Reasons (2017)
Singles
As lead artist
Notes
References
External links
1992 births
Living people
African-American male rappers
American male rappers
Rappers from Atlanta
Southern hip hop musicians
African-American songwriters
Songwriters from Georgia (U.S. state)
21st-century American rappers
21st-century American male musicians
21st-century African-American musicians
American male songwriters
|
Yamangalea is a genus of South Pacific jumping spiders that was first described by Wayne Paul Maddison in 2009. it contains two species, found in Australia and Papua New Guinea: Y. frewana and Y. lubinae.
References
External links
Yamangalea frewana
Salticidae genera
Salticidae
Spiders of Australia
|
```nix
{ network ? "staging"
, os ? "linux"
, cardanoLib
, runCommand
, lib
, devShell ? false
, topologyOverride ? null
, configOverride ? null
, genesisOverride ? null
, cardano-playground
, system
}:
# Creates an attr set for a cluster containing:
# * launcherConfig (attr set)
# * installerConfig (attr set)
# * nodeConfigFiles
# * configFiles (launcher config + installer config)
let
clustersAvailable = rec {
mainnet = fromCardanoPlayground "mainnet";
mainnet_flight = mainnet;
shelley_qa = fromCardanoPlayground "shelley_qa";
vasil_dev = fromCardanoPlayground "vasil-dev";
preprod = fromCardanoPlayground "preprod";
preview = fromCardanoPlayground "preview";
};
smashServers = {
mainnet = "path_to_url";
preprod = "path_to_url";
preview = "path_to_url";
};
fromCardanoPlayground = envName: let
originalFiles = builtins.path {
name = "cardano-playground-config-${envName}";
path = cardano-playground + ("/static/book.play.dev.cardano.org/environments/" + envName);
};
originalNodeConfig = builtins.fromJSON (builtins.unsafeDiscardStringContext (
builtins.readFile (originalFiles + "/config.json")));
nodeConfig = originalNodeConfig // {
AlonzoGenesisFile = originalFiles + "/" + originalNodeConfig.AlonzoGenesisFile;
ByronGenesisFile = originalFiles + "/" + originalNodeConfig.ByronGenesisFile;
ShelleyGenesisFile = originalFiles + "/" + originalNodeConfig.ShelleyGenesisFile;
minSeverity = "Info"; # XXX: Needed for sync % updates.
} // (if originalNodeConfig ? ConwayGenesisFile then {
ConwayGenesisFile = originalFiles + "/" + originalNodeConfig.ConwayGenesisFile;
} else {});
in {
cluster = envName;
networkName = envName;
cardanoEnv = {
inherit nodeConfig;
topologyFile = originalFiles + "/topology.json";
};
};
dirSep = if os == "windows" then "\\" else "/";
configDir = configFilesSource: {
linux = if devShell then configFilesSource else "\${ENTRYPOINT_DIR}/config";
macos64 = if devShell then configFilesSource else "\${DAEDALUS_INSTALL_DIRECTORY}/../Resources";
macos64-arm = if devShell then configFilesSource else "\${DAEDALUS_INSTALL_DIRECTORY}/../Resources";
windows = "\${DAEDALUS_INSTALL_DIRECTORY}";
};
mkSpacedName = network: "Daedalus ${installDirectorySuffix}";
spacedName = mkSpacedName network;
frontendBinPath = let
frontendBin.linux = "daedalus-frontend";
frontendBin.windows = "${spacedName}";
frontendBin.macos64 = "Frontend";
frontendBin.macos64-arm = "Frontend";
in frontendBin.${os};
selfnodeConfig = rec {
useByronWallet = true;
private = false;
networkConfig = import ./selfnode-config.nix;
nodeConfig = networkConfig // cardanoLib.defaultLogConfig;
consensusProtocol = networkConfig.Protocol;
genesisFile = ../../utils/cardano/selfnode/genesis.json;
delegationCertificate = ../../utils/cardano/selfnode/selfnode.cert;
signingKey = ../../utils/cardano/selfnode/selfnode.key;
topology = ../../utils/cardano/selfnode/selfnode-topology.json;
};
# Helper function to make a path to a binary
mkBinPath = binary: let
binDir = {
macos64 = "\${DAEDALUS_INSTALL_DIRECTORY}";
macos64-arm = "\${DAEDALUS_INSTALL_DIRECTORY}";
windows = "\${DAEDALUS_INSTALL_DIRECTORY}";
};
binary' = if binary == "frontend" then frontendBinPath else binary;
in if (devShell || os == "linux") then binary' else "${binDir.${os}}${dirSep}${binary'}${lib.optionalString (os == "windows") ".exe"}";
# Helper function to make a path to a config file
mkConfigPath = configSrc: configPath: "${(configDir configSrc).${os}}${dirSep}${configPath}";
envCfg = let
cardanoEnv = clustersAvailable.${network}.cardanoEnv;
in if network == "selfnode" then selfnodeConfig else cardanoEnv;
kind = if network == "local" then "shelley" else if (envCfg.nodeConfig.Protocol == "RealPBFT" || envCfg.nodeConfig.Protocol == "Byron") then "byron" else "shelley";
installDirectorySuffix = let
supportedNetworks = {
mainnet = "Mainnet";
mainnet_flight = "Flight";
selfnode = "Selfnode";
local = "Local";
staging = "Staging";
testnet = "Testnet";
shelley_qa = "Shelley QA";
alonzo_purple = "Alonzo Purple";
vasil_dev = "Vasil-Dev";
preprod = "Pre-Prod";
preview = "Preview";
};
unsupported = "Unsupported";
networkSupported = __hasAttr network supportedNetworks;
in if networkSupported then supportedNetworks.${network} else unsupported;
iconPath = let
networkIconExists = __pathExists (../../. + "/installers/icons/${network}");
network' = if networkIconExists then network else "mainnet";
in {
small = ../../installers/icons + "/${network'}/64x64.png";
large = ../../installers/icons + "/${network'}/1024x1024.png";
base = ../../installers/icons + "/${network'}";
};
dataDir = let
path.linux = "\${XDG_DATA_HOME}/Daedalus/${network}";
path.macos64 = "\${HOME}/Library/Application Support/${spacedName}";
path.macos64-arm = "\${HOME}/Library/Application Support/${spacedName}";
path.windows = "\${APPDATA}\\${spacedName}";
in path.${os};
# Used for flight builds to find legacy paths for migration
legacyDataDir = let
path.linux = "\${XDG_DATA_HOME}/Daedalus/mainnet";
path.macos64 = "\${HOME}/Library/Application Support/Daedalus";
path.macos64-arm = "\${HOME}/Library/Application Support/Daedalus";
path.windows = "\${APPDATA}\\Daedalus";
in path.${os};
logsPrefix = let
path.linux = "${dataDir}/Logs";
path.windows = "Logs";
path.macos64 = "${dataDir}/Logs";
path.macos64-arm = "${dataDir}/Logs";
in path.${os};
tlsConfig = {
ca = {
organization = "Daedalus";
commonName = "Daedalus Self-Signed Root CA";
expiryDays = 3650;
};
server = {
organization = "Daedalus";
commonName = "Daedalus Wallet Backend";
expiryDays = 365;
altDNS = [
"localhost"
"localhost.localdomain"
"127.0.0.1"
"::1"
];
};
clients = [ {
organization = "Daedalus";
commonName = "Daedalus Frontend";
expiryDays = 365;
} ];
};
launcherLogsPrefix = "${logsPrefix}${dirSep}pub";
# Default configs for launcher from cardano-shell. Most of these do nothing.
# TODO: get rid of anything we don't need from cardano-shell
defaultLauncherConfig = {
inherit logsPrefix launcherLogsPrefix tlsConfig;
walletLogging = false;
daedalusBin = mkBinPath "frontend";
updateRunnerBin = mkBinPath "update-runner";
# TODO: set when update system is complete
updaterArgs = [];
updaterPath = "";
updateArchive = "";
updateWindowsRunner = "";
workingDir = dataDir;
stateDir = dataDir;
tlsPath = "${dataDir}${dirSep}tls";
cluster = if __hasAttr network clustersAvailable then clustersAvailable.${network}.cluster else network;
networkName = if __hasAttr network clustersAvailable then clustersAvailable.${network}.networkName else network;
isFlight = network == "mainnet_flight";
isStaging = (envCfg.nodeConfig.RequiresNetworkMagic == "RequiresNoMagic");
nodeImplementation = "cardano";
};
mkConfigFiles = nodeConfigFiles: launcherConfig: installerConfig:
runCommand "cfg-files" {
launcherConfig = builtins.toJSON launcherConfig;
installerConfig = builtins.toJSON installerConfig;
passAsFile = [ "launcherConfig" "installerConfig" ];
} ''
mkdir $out
cp ${nodeConfigFiles}/* $out/
cp $launcherConfigPath $out/launcher-config.yaml
cp $installerConfigPath $out/installer-config.json
${lib.optionalString (envCfg.nodeConfig ? ByronGenesisFile) "cp ${envCfg.nodeConfig.ByronGenesisFile} $out/genesis-byron.json"}
${lib.optionalString (envCfg.nodeConfig ? ShelleyGenesisFile) "cp ${envCfg.nodeConfig.ShelleyGenesisFile} $out/genesis-shelley.json"}
${lib.optionalString (envCfg.nodeConfig ? AlonzoGenesisFile) "cp ${envCfg.nodeConfig.AlonzoGenesisFile} $out/genesis-alonzo.json"}
${lib.optionalString (envCfg.nodeConfig ? ConwayGenesisFile) "cp ${envCfg.nodeConfig.ConwayGenesisFile} $out/genesis-conway.json"}
'';
mkConfigCardano = let
filterMonitoring = config: if devShell then config else builtins.removeAttrs config [ "hasPrometheus" "hasEKG" ];
cardanoAddressBin = mkBinPath "cardano-address";
walletBin = mkBinPath "cardano-wallet";
nodeBin = mkBinPath "cardano-node";
cliBin = mkBinPath "cardano-cli";
nodeConfig = let
nodeConfigAttrs = if (configOverride == null) then envCfg.nodeConfig else __fromJSON (__readFile configOverride);
in builtins.toJSON (filterMonitoring (nodeConfigAttrs // (lib.optionalAttrs (!devShell || network == "local") ({
ByronGenesisFile = "genesis-byron.json";
ShelleyGenesisFile = "genesis-shelley.json";
AlonzoGenesisFile = "genesis-alonzo.json";
} // (if nodeConfigAttrs ? ConwayGenesisFile then {
ConwayGenesisFile = "genesis-conway.json";
} else {})))));
genesisFile = let
genesisFile'.selfnode = ../../utils/cardano/selfnode/genesis.json;
genesisFile'.local = (__fromJSON nodeConfig).GenesisFile;
in if (genesisOverride != null) then genesisOverride else if (network == "selfnode" || network == "local") then genesisFile'.${network} else envCfg.nodeConfig.ByronGenesisFile;
normalTopologyFile = if network == "selfnode" then envCfg.topology else throw "no longer supported";
localTopology = cardanoLib.mkEdgeTopology {
edgePort = 30001;
edgeNodes = [ "127.0.0.1" ];
};
topologyFile =
if envCfg ? topologyFile
then envCfg.topologyFile
else if (topologyOverride == null)
then (if network == "local"
then localTopology
else normalTopologyFile)
else topologyOverride;
nodeConfigFiles = runCommand "node-cfg-files" {
inherit nodeConfig topologyFile;
passAsFile = [ "nodeConfig" ];
} ''
mkdir $out
cp ${genesisFile} $out/genesis.json
cp $nodeConfigPath $out/config.yaml
cp $topologyFile $out/topology.yaml
${lib.optionalString (network == "selfnode") ''
cp ${envCfg.delegationCertificate} $out/delegation.cert
cp ${envCfg.signingKey} $out/signing.key
''}
'';
legacyStateDir = if (network == "mainnet_flight") || (network == "mainnet") then legacyDataDir else dataDir;
legacyWalletDB = let
path.linux = "Wallet";
path.macos64 = "Wallet-1.0";
path.macos64-arm = "Wallet-1.0";
path.windows = "Wallet-1.0";
in path.${os};
legacySecretKey = let
path.linux = "Secrets${dirSep}secret.key";
path.macos64 = "Secrets-1.0${dirSep}secret.key";
path.macos64-arm = "Secrets-1.0${dirSep}secret.key";
path.windows = "Secrets-1.0${dirSep}secret.key";
in path.${os};
launcherConfig = defaultLauncherConfig // {
inherit
nodeBin
cliBin
walletBin
cardanoAddressBin
legacyStateDir
legacyWalletDB
legacySecretKey;
syncTolerance = "300s";
nodeConfig = {
inherit kind;
configurationDir = "";
network = {
configFile = mkConfigPath nodeConfigFiles "config.yaml";
genesisFile = mkConfigPath nodeConfigFiles "genesis.json";
topologyFile = mkConfigPath nodeConfigFiles "topology.yaml";
};
};
} // (lib.optionalAttrs (network == "selfnode") {
selfnodeBin = mkBinPath "local-cluster";
mockTokenMetadataServerBin = mkBinPath "mock-token-metadata-server";
}) // (lib.optionalAttrs (__hasAttr network smashServers) {
smashUrl = smashServers.${network};
}) // (lib.optionalAttrs (__hasAttr "metadataUrl" envCfg) {
metadataUrl = envCfg.metadataUrl;
});
installerConfig = {
installDirectory = if os == "linux" then "Daedalus/${network}" else spacedName;
inherit spacedName iconPath;
uglyName = "daedalus";
macPackageName = "Daedalus${network}";
dataDir = dataDir;
installerWinBinaries = [
"cardano-launcher.exe"
"cardano-node.exe"
"cardano-wallet.exe"
"cardano-cli.exe"
"cardano-address.exe"
];
};
in {
inherit nodeConfigFiles launcherConfig installerConfig;
configFiles = mkConfigFiles nodeConfigFiles launcherConfig installerConfig;
};
in mkConfigCardano
```
|
A rigid gas-permeable lens, also known as an RGP lens, GP lens, or colloquially, a hard contact lens, is a rigid contact lens made of oxygen-permeable polymers. Initially developed in the late 1970s, and through the 1980s and 1990s, they were an improvement over prior 'hard' lenses that restricted oxygen transmission to the eye.
Rigid lenses are able to replace the natural shape of the cornea with a new refracting surface. This means that a regular (spherical) rigid contact lens can provide good level of vision in people who have astigmatism or distorted corneal shapes as with keratoconus. However, they require a period of adaptation before full comfort is achieved.
RGP lenses have various benefits over soft contact lenses, including better durability, clearer vision, and a lower risk of eye infections, claim Hashemi et al. (2019). However, they demand a lengthier adaption period and more specific fitting.
References
External links
What Are GP Contact Lenses? by Contact Lens Manufacturers Association (CLMA)
Contact lenses
|
Timothy Turner (1585–1677) was an English judge.
Timothy Turner or Tim Turner may also refer to:
Timothy Turner (actor), voice actor featured in shows including The Many Adventures of Winnie the Pooh
Tim Turner (1924–1987), British actor
Tim Turner (Canadian rower) (born 1959)
Tim Turner (English rower) (fl. 1938)
Timmy T. Turner, fictional TV character (The Fairly OddParents)
William Irving Turner (1890–1950), U.S. Forest Service architect known as Tim Turner
|
Limited Snowboards was a Canadian snowboard brand founded in Toronto in 1993 by Perry Gladstone and Ricardo Camargo. Limited Snowboards Inc. and its successors distributed snowboards bindings, boots, clothing and accessories under the brands Limited and LTD.
Backstory
In 1989 and 1990 Perry produced his first snowboards under the Fishlips brand, a Canadian skateboard company he owned and operated. The line was discontinued and then restarted in 1991 as a collaboration with H-Street Skateboards' co-founder Tony Magnusson. In the winter of 1992, Perry recruited Ricardo to help him with the project until a former H-street investor challenged the brand ownership and Perry, Ricardo and Tony chose to abandon the project and create new brands of their own.
First year
The first year of Limited's operations were run from Perry's kitchen desk, where he negotiated a manufacturing agreement with the upstart snowboard factory Surf Politix of Sainte Anne de Beaupré, Quebec. Two models were produced based on designs by Ricardo, graphic designer Todd De Koker and Limited's first team rider, Emanuel Krebs. Production was financed by a $30,000 Letter of Credit provided in advance by Japanese distributor Car Mate Manufacturing Ltd.,$15,000 in personal loans to the company by Perry and Ricardo and a matching $15,000 government-backed young entrepreneur loan from the Bank of Montreal. Approximately 300 boards were made the first season and, following delivery, Perry bought out Ricardo for his initial loan amount plus nominal goodwill and became the sole director of the company.
Big in Japan
Although Canadian stores were slow on the uptake, Car Mate was very successful with the Limited brand and sales in Japan increased. In year two just under 1000 boards were produced. To advertise the Limited brand in Canada, Perry founded Vehicle Magazine, a quarterly action sports publication, which featured Limited products and advertisements alongside articles about local skateboarders and snowboarders. By year three the brand became popular in both Canada and the US and sales exceeded the one million dollar mark. To accommodate increasing demand for lower price points, production of the Limited brand was moved to the Pale Ski & Sport factory in Austria and a higher-end series of LTD branded boards were contracted to Industries Esthete Inc., in Chicoutimi, Quebec.
Largest Canadian brand
By 1996 Limited was the largest Canadian snowboard brand worldwide with distributors in 14 countries. Micah Kornberg joined the company in the summer of 1996 as partner and COO and, in 1997, facilitated a series of investments in the company by labor-sponsored venture corporation, Sport Fund. With Sport Fund's support, Limited sought out potential acquisitions but was unable to close a deal before heavy industry consolidation forced the company to entertain offers from other suitors. In 1998, Limited Snowboards Inc. wound down its Canadian operations and sold the assets to the Volant Ski Company, LLC of Denver Colorado for an undisclosed amount. To facilitate the sale and integrate operations, Perry moved to Colorado as Volant's Director of Snowboarding. Micah also left Toronto to run competitor Sims Snowboards in Seattle, Washington.
American engineering
The Volant Ski Company was famous for its stainless steel cap technology, which, while heavy, produced very responsive handling. To replicate this effect in a snowboard the Volant engineering team created the Powerband, a flat figure-eight band of stainless steel laminated above and below the wooden core. A series of limited boards ‘Powered by Volant’ were produced by Volant for the 1998/99 season while manufacturing of the LTD premium line remained with Industries Esthete in Canada.
Due to the labour-intensive construction and high cost of manufacturing in the United States, Volant had never turned a profit. One year after acquiring Limited, the Volant board of directors, led by angel investor Mike Markkula, decided to get out of snowboarding and invest in opposite season products. In 2000 Perry left Volant to pursue other interests after facilitating the sale of the Limited brand and all its assets to the Authentic Brands Group. Shortly after, the Authentic Brand Group also acquired Sims Snowboards, prompting Micah to leave the industry as well.
References
Further reading
Snowboarding companies
1993 establishments in Ontario
|
Port Ryerse is a fishing hamlet in Norfolk County, Ontario, Canada, southwest of Port Dover. The hamlet is popular with persons from Southwestern Ontario who rent cottages and fish for pleasure during the summer months (Victoria Day through mid-October).
Many of the residents live here year-round. Most of the people here drive to Port Dover or Simcoe to purchase groceries and other goods, although there was a historic general store until September 2004, when it burned down. Handmade soap and bath shop and folk art shop still exist in the community.
This community lies at the mouth of Young's Creek (popular with trout fishermen) and empties into Long Point Bay. Nearby is Hay Creek Conservation Area, that can be used year-round and is suitable for hiking, walking, cycling cross-country skiing and snowshoeing.
History
The hamlet was founded by Lieutenant-Colonel Samuel Ryerse, brother of Colonel Joseph Ryerson and uncle of Egerton Ryerson. Ryerse served with the New Jersey Volunteers and later commanded the 1st Norfolk Militia.
Its harbor was important for shipping cargo from Norfolk County across the lake; although its importance declined significantly sometime around the 1880s due to the advent of the railroad.
Samuel Ryerse was a United Empire Loyalist who fought with the British during the American Revolution and came to Upper Canada in 1794 where he received 3000 acres of land. He built a grist mill at the mouth of Young's Creek and a settlement grew up around it. Ryerse remained involved with the military as Lieutenant of the County of Norfolk and was also the chairman of the Court of Quarter Sessions.
The mill was burned by American troops in 1814 during the War of 1812. In later years, two new gristmills were built at the same location but both burned down (in 1860 and in 1890). A brick schoolhouse was built in 1871.
Port Ryerse is also the birthplace of John Edward Brownlee, who was the Premier of the province of Alberta during the Roaring Twenties and through the early years of the Great Depression. John Brownlee had one sister, Maude, born September 12, 1888. The Brownlees lived in the general store building, and it was here that John spent the happiest times of his childhood: he much preferred his parents' books, their political discussions with neighbours, and the details of their business to life outside the store. One anecdote has the village children, displeased with his serious temperament, throwing him into Lake Erie. By the age of seven, John was assisting at the store with such tasks as mixing butter from the different dairies with which his father dealt to produce a standardized blend.
A public elementary school called Port Ryerse School was located here that was in operation from the 19th century to the 1950s. Both Caucasian and African-Canadian students were photographed attending the school in the year 1898. The teacher shown in the 1898 school photograph was Miss A. Exelby and the picture was taken on September 14, 1898.
At least 194 different species of bird have been discovered here between 1875 and 2019; including the Passenger pigeon, the Indigo bunting, and the Northern cardinal.
In 2001, Haldimand-Norfolk was dissolved into two separate single-tier counties. Port Ryerse became part of the newly formed County of Norfolk.
Cemetery
The Memorial Anglican Church Cemetery is located in the hamlet; with at least 26 individuals or families buried here.
There are various traditional British surnames like Fletcher, Lawrence, Ryerse, Sells, and Stalker among those buried at this cemetery. The most recent burial in the Memorial Anglican Church Cemetery happens to be of Miss Sarah Fletcher (who died in 1880). Lieut-Colonel Samuel Vanderhoff Ryerse Sr. was the oldest known male to be buried in this cemetery (died in 1812) while the oldest known female to be buried at this cemetery is Sarah Ryerse (née Underhill; died in 1838 in her 81st year).
Climate
From the late 1990s onwards, winters have become more mild due to changes in climate brought on by global warming. Port Ryerse traditionally belongs to the humid continental climate zone, even with the recent mild winters and warmer dry summers. Like in all communities, towns, and cities throughout the world, global warming due to human industrial activity has drastically altered the climate of Port Ryerse throughout the decades.
Should the sea levels rise by , Port Ryerse would not be affected by flooding. However, it may be affected by droughts as a by-product of the dislocation of available fresh water and may be forced to rely on desalinated salt water piped in from the Eastern United States. Constructing the proper infrastructure to carry the water hundreds of miles away would take considerable manpower along with significant economic costs and an unprecedented level of cooperation from multiple federal, state/provincial, and municipal governments.
References
Bibliography
Communities in Norfolk County, Ontario
Populated places on Lake Erie in Canada
|
```java
/*
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
*
* 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 org.apache.shardingsphere.sql.parser.api.visitor.statement.type;
import org.apache.shardingsphere.sql.parser.api.visitor.statement.SQLStatementVisitor;
/**
* DDL statement visitor.
*/
public interface DDLStatementVisitor extends SQLStatementVisitor {
}
```
|
Fish Creek flows into the Black River near Greig, New York.
References
Rivers of New York (state)
|
```xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="path_to_url"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:gravity="center"
android:background="@color/whitebackground"
android:layoutDirection="rtl"
android:textAlignment="center"
android:focusable="false"
android:focusableInTouchMode="false"
>
<LinearLayout
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:gravity="center"
android:layoutDirection="rtl"
android:textAlignment="center"
android:layout_marginRight="10dp"
android:layout_marginLeft="10dp"
android:layout_marginTop="5dp"
android:paddingRight="5dp"
android:background="@drawable/background"
android:paddingTop="2dp"
android:paddingBottom="1dp"
>
<LinearLayout
android:orientation="horizontal"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="0"
android:gravity="center"
android:layoutDirection="ltr"
android:textAlignment="center"
android:background="@drawable/background"
android:paddingTop="1dp"
android:paddingBottom="1dp"
android:paddingLeft="3dp"
android:paddingRight="3dp">
<TextView
android:paddingEnd="1dp"
android:layout_weight="0"
android:background="@color/white"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceSmall"
android:text="2015-12-11"
android:textSize="10dp"
android:id="@+id/txt_tweet_date" />
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="User name"
android:id="@+id/txtUserName"
android:layout_alignParentTop="true"
android:gravity="right"
android:background="@color/white"
android:focusable="false"
android:focusableInTouchMode="false"
android:layout_toLeftOf="@+id/webView"
android:layout_toRightOf="@+id/bulogin"
android:layout_toEndOf="@+id/bulogin"
android:layout_weight="1"
android:textColor="#0894f8"
android:textSize="12dp"
android:textStyle="bold"
android:paddingRight="3dp" />
<ImageView
android:layout_width="50px"
android:layout_height="50px"
android:src="@drawable/ic_account_circle_black_24dp"
android:id="@+id/picture_path"
android:layout_alignParentTop="true"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:layout_alignBottom="@+id/txtflollower"
android:layout_weight="0"
android:background="@color/lowDarkfont" />
</LinearLayout>
<TextView
android:fontFamily="sans-serif-medium"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:paddingRight="5dp"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="Love new twitter feathers, looking forword for new addation feather"
android:id="@+id/txt_tweet"
android:layout_alignParentTop="true"
android:gravity="left"
android:textAlignment="gravity"
android:background="@color/white"
android:layout_toLeftOf="@+id/webView"
android:layout_toRightOf="@+id/bulogin"
android:layout_toEndOf="@+id/bulogin"
android:paddingBottom="2dp"
android:textSize="18dp"
android:textColor="#040101" />
<ImageView
android:background="@drawable/background"
android:adjustViewBounds="true"
android:scaleType="fitXY"
android:layout_width="fill_parent"
android:src="@drawable/twitter"
android:layout_marginLeft="5dp"
android:layout_marginRight="5dp"
android:id="@+id/tweet_picture"
android:layout_alignParentTop="true"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:layout_alignBottom="@+id/txtflollower"
android:layout_weight="0"
android:layout_marginBottom="1dp"
android:layout_height="90pt" />
<LinearLayout
android:paddingLeft="10dp"
android:paddingRight="3dp"
android:paddingTop="3dp"
android:paddingBottom="5dp"
android:layoutDirection="ltr"
android:orientation="horizontal"
android:background="@drawable/background"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ImageView
android:layout_width="25dp"
android:layout_height="25dp"
android:id="@+id/iv_share"
android:layout_marginRight="8dp"
android:background="@drawable/ic_favorite_border_black_24dp" />
</LinearLayout>
<LinearLayout
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"></LinearLayout>
</LinearLayout>
</LinearLayout>
```
|
Bartholomew of Brescia (b. probably in the second half of the 12th century at Brescia; died 1258) was an Italian canonist.
Life
He studied Roman and ecclesiastical law at Bologna, where he himself became a teacher. It is believed that he was murdered, when Ezzelino, the leader of the Ghibellines, captured Brescia (1258).
Works
His literary work consisted almost entirely in the revision of the productions of other writers. His "Brocarda", or Canonical Rules (Lyons, 1519), were a working-over of those of Damasus (12th and 13th centuries); his "Casus decretorum" were a revision of the "Casus" of Benencasa (d. c. 1206); the "Historiae super libro Decretorum" reproduced the work of an unknown author. Both his "Casus" and "Historiae" derive their importance from their incorporation into the Paris edition (1505) of Gratian's Decretum.
The "Ordo Judiciarius" of Tancred (d. c. 1235) was also revised by Bartholomew.
More important than the preceding works was his "Glossa Ordinaria" to the "Decretum" of Gratian, a correction of the "Glossa", or "Apparatus", of Johannes Teutonicus Zemeke (13th century). His only certain independent work was the "Quaestiones dominicales et veneriales", lectures delivered on Sundays and Fridays.
Editions
References
Schulte, Gesch. der Quellen u. Literatur des kan. Rechts (Stuttgart, 1875–80), II, 83-88
Scherer in Kirchenlexikon (2d ed., Freiburg, 1882), I, 2055, 2056
Hugo von Hurter, Nomenclator literarius theologiae catholicae (3rd ed., 1903)
External links
Casus decretorum, 1301-1325, at the National Library of Portugal
Ordo judiciarius, 1351-1400, at the National Library of Portugal
1258 deaths
Canon law jurists
13th-century Italian jurists
Year of birth unknown
13th-century writers in Latin
|
```shell
#!/usr/bin/env bash
set -eo pipefail
CREATE_UPDATES_RESOURCES_MODE="all"
if [[ "$SKIP_BUNDLING" ]]; then
echo "SKIP_BUNDLING enabled; skipping create-manifest-ios.sh."
CREATE_UPDATES_RESOURCES_MODE="only-fingerprint"
elif [[ "$CONFIGURATION" == *Debug* ]]; then
if [[ "$FORCE_BUNDLING" ]]; then
echo "FORCE_BUNDLING enabled; continuing create-manifest-ios.sh."
else
CREATE_UPDATES_RESOURCES_MODE="only-fingerprint"
fi
fi
EXPO_UPDATES_PACKAGE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
DEST="$CONFIGURATION_BUILD_DIR"
RESOURCE_BUNDLE_NAME="EXUpdates.bundle"
RCT_METRO_PORT=${RCT_METRO_PORT:=8081}
# For classic main project build phases integration, will be no-op to prevent duplicated app.manifest or fingerprint creation.
#
# `$PROJECT_DIR` is passed by Xcode as the directory to the xcodeproj file.
# in classic main project setup it is something like /path/to/app/ios
# in new style pod project setup it is something like /path/to/app/ios/Pods
PROJECT_DIR_BASENAME=$(basename $PROJECT_DIR)
if [ "x$PROJECT_DIR_BASENAME" != "xPods" ]; then
exit 0
fi
# If PROJECT_ROOT is not specified, fallback to use Xcode PROJECT_DIR
PROJECT_ROOT=${PROJECT_ROOT:-"$PROJECT_DIR/../.."}
PROJECT_ROOT=${PROJECT_ROOT:-"$EXPO_UPDATES_PACKAGE_DIR/../.."}
cd "$PROJECT_ROOT" || exit
# We should get the physical path (/var/folders -> /private/var/folders) for metro to resolve correct files
PROJECT_ROOT="$(pwd -P)"
"${EXPO_UPDATES_PACKAGE_DIR}/scripts/with-node.sh" "${EXPO_UPDATES_PACKAGE_DIR}/utils/build/createUpdatesResources.js" ios "$PROJECT_ROOT" "$DEST/$RESOURCE_BUNDLE_NAME" "$CREATE_UPDATES_RESOURCES_MODE" "$ENTRY_FILE"
```
|
Lukestar was an indie rock band based in Oslo, Norway. , the band was signed to the label 'Tuba Records', among others. They are known for their musical fusion of hardcore punk and indie rock.
Biography
The band was formed in 1995 under the name Luke Warm, but the name was later changed to Lukestar. In 2002, they released their first EP entitled Code: Distance, and two years later, in 2004, they released their debut full-length album Alpine Unit. In January 2008, the band's second album Lake Toba was released. Also in 2008, band members Even Djønne, and Eirik L. Bærulfsen, were replaced by Jørgen Larsen, and Torbjørn Hafnor, from hardcore punk band The Spectacle.
Lukestar received the 2008 Spelleman Award (The Norwegian Grammy Award 2008, Spellemannprisen), in the category Best Rock Band for the album Lake Toba. In February 2011, Lukestar released their third album Taiga. The first single from this album "Flying Canoes," was A-listed on NRK P3. The band broke up in 2012, and played farewell concert at Parkteatret in Oslo on 31 August.
Vocalist Truls Heggero had great success as solo artist and released the album TRVLS (pronounced travels) in 2013, which had two giant hits: "Out Of Yourself," and "The Next".
Honors
2008: Spellemannprisen in the category Rock music, for the album Lake Toba
Discography
2002: Code: Distance [EP] (Machine Machine / Phone MeHandmade / Rec 90)
2004: Alpine Unit (ChewinPine)
2007: White Shade 7" (Phone Me)
2008: Lake Toba (Phone Me / Tuba Records/Flameshovel)
2011: Taiga
2011: Great Bear [EP]
References
External links
Lukestar at Underhill Records
Lukestar at Rock's My Ass Records
Norwegian indie rock groups
Norwegian punk rock groups
Post-hardcore groups
Norwegian pop music groups
Power pop groups
Musical groups established in 1995
1995 establishments in Norway
Spellemannprisen winners
Musical groups from Oslo
Flameshovel Records artists
|
```python
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# ==============================================================================
"""FisherBlock definitions."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import abc
import six
from tensorflow.contrib.kfac.python.ops import fisher_factors
from tensorflow.contrib.kfac.python.ops import utils
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import math_ops
# For blocks corresponding to convolutional layers, or any type of block where
# the parameters can be thought of as being replicated in time or space,
# we want to adjust the scale of the damping by
# damping /= num_replications ** NORMALIZE_DAMPING_POWER
NORMALIZE_DAMPING_POWER = 1.0
@six.add_metaclass(abc.ABCMeta)
class FisherBlock(object):
"""Abstract base class for objects modeling approximate Fisher matrix blocks.
Subclasses must implement multiply_inverse(), instantiate_factors(), and
tensors_to_compute_grads() methods.
"""
def __init__(self, layer_collection):
self._layer_collection = layer_collection
@abc.abstractmethod
def instantiate_factors(self, grads_list, damping):
"""Creates and registers the component factors of this Fisher block.
Args:
grads_list: A list gradients (each a Tensor or tuple of Tensors) with
respect to the tensors returned by tensors_to_compute_grads() that
are to be used to estimate the block.
damping: The damping factor (float or Tensor).
"""
pass
@abc.abstractmethod
def multiply_inverse(self, vector):
"""Multiplies the vector by the (damped) inverse of the block.
Args:
vector: The vector (a Tensor or tuple of Tensors) to be multiplied.
Returns:
The vector left-multiplied by the (damped) inverse of the block.
"""
pass
@abc.abstractmethod
def multiply(self, vector):
"""Multiplies the vector by the (damped) block.
Args:
vector: The vector (a Tensor or tuple of Tensors) to be multiplied.
Returns:
The vector left-multiplied by the (damped) block.
"""
pass
@abc.abstractmethod
def tensors_to_compute_grads(self):
"""Returns the Tensor(s) with respect to which this FisherBlock needs grads.
"""
pass
class FullFB(FisherBlock):
"""FisherBlock using a full matrix estimate (no approximations).
FullFB uses a full matrix estimate (no approximations), and should only ever
be used for very low dimensional parameters.
Note that this uses the naive "square the sum estimator", and so is applicable
to any type of parameter in principle, but has very high variance.
"""
def __init__(self, layer_collection, params, batch_size):
"""Creates a FullFB block.
Args:
layer_collection: The collection of all layers in the K-FAC approximate
Fisher information matrix to which this FisherBlock belongs.
params: The parameters of this layer (Tensor or tuple of Tensors).
batch_size: The batch size, used in the covariance estimator.
"""
self._batch_size = batch_size
self._params = params
super(FullFB, self).__init__(layer_collection)
def instantiate_factors(self, grads_list, damping):
self._damping = damping
self._factor = self._layer_collection.make_or_get_factor(
fisher_factors.FullFactor, (grads_list, self._batch_size))
self._factor.register_damped_inverse(damping)
def multiply_inverse(self, vector):
inverse = self._factor.get_inverse(self._damping)
out_flat = math_ops.matmul(inverse, utils.tensors_to_column(vector))
return utils.column_to_tensors(vector, out_flat)
def multiply(self, vector):
vector_flat = utils.tensors_to_column(vector)
out_flat = (math_ops.matmul(self._factor.get_cov(), vector_flat) +
self._damping * vector_flat)
return utils.column_to_tensors(vector, out_flat)
def full_fisher_block(self):
"""Explicitly constructs the full Fisher block."""
return self._factor.get_cov()
def tensors_to_compute_grads(self):
return self._params
class NaiveDiagonalFB(FisherBlock):
"""FisherBlock using a diagonal matrix approximation.
This type of approximation is generically applicable but quite primitive.
Note that this uses the naive "square the sum estimator", and so is applicable
to any type of parameter in principle, but has very high variance.
"""
def __init__(self, layer_collection, params, batch_size):
"""Creates a NaiveDiagonalFB block.
Args:
layer_collection: The collection of all layers in the K-FAC approximate
Fisher information matrix to which this FisherBlock belongs.
params: The parameters of this layer (Tensor or tuple of Tensors).
batch_size: The batch size, used in the covariance estimator.
"""
self._params = params
self._batch_size = batch_size
super(NaiveDiagonalFB, self).__init__(layer_collection)
def instantiate_factors(self, grads_list, damping):
self._damping = damping
self._factor = self._layer_collection.make_or_get_factor(
fisher_factors.NaiveDiagonalFactor, (grads_list, self._batch_size))
def multiply_inverse(self, vector):
vector_flat = utils.tensors_to_column(vector)
out_flat = vector_flat / (self._factor.get_cov() + self._damping)
return utils.column_to_tensors(vector, out_flat)
def multiply(self, vector):
vector_flat = utils.tensors_to_column(vector)
out_flat = vector_flat * (self._factor.get_cov() + self._damping)
return utils.column_to_tensors(vector, out_flat)
def full_fisher_block(self):
return array_ops.diag(array_ops.reshape(self._factor.get_cov(), (-1,)))
def tensors_to_compute_grads(self):
return self._params
class FullyConnectedDiagonalFB(FisherBlock):
"""FisherBlock for fully-connected (dense) layers using a diagonal approx.
Unlike NaiveDiagonalFB this uses the low-variance "sum of squares" estimator
that is computed using the well-known trick.
"""
# TODO(jamesmartens): add units tests for this class
def __init__(self, layer_collection, inputs, outputs, has_bias=False):
"""Creates a FullyConnectedDiagonalFB block.
Args:
layer_collection: The collection of all layers in the K-FAC approximate
Fisher information matrix to which this FisherBlock belongs.
inputs: The Tensor of input activations to this layer.
outputs: The Tensor of output pre-activations from this layer.
has_bias: Whether the component Kronecker factors have an additive bias.
(Default: False)
"""
self._inputs = inputs
self._outputs = outputs
self._has_bias = has_bias
super(FullyConnectedDiagonalFB, self).__init__(layer_collection)
def instantiate_factors(self, grads_list, damping):
self._damping = damping
self._factor = self._layer_collection.make_or_get_factor(
fisher_factors.FullyConnectedDiagonalFactor, (self._inputs, grads_list,
self._has_bias))
def multiply_inverse(self, vector):
reshaped_vect = utils.layer_params_to_mat2d(vector)
reshaped_out = reshaped_vect / (self._factor.get_cov() + self._damping)
return utils.mat2d_to_layer_params(vector, reshaped_out)
def multiply(self, vector):
reshaped_vect = utils.layer_params_to_mat2d(vector)
reshaped_out = reshaped_vect * (self._factor.get_cov() + self._damping)
return utils.mat2d_to_layer_params(vector, reshaped_out)
def tensors_to_compute_grads(self):
return self._outputs
class ConvDiagonalFB(FisherBlock):
"""FisherBlock for convolutional layers using a diagonal approx.
Unlike NaiveDiagonalFB this uses the low-variance "sum of squares" estimator.
"""
# TODO(jamesmartens): add units tests for this class
def __init__(self, layer_collection, params, inputs, outputs, strides,
padding):
"""Creates a ConvDiagonalFB block.
Args:
layer_collection: The collection of all layers in the K-FAC approximate
Fisher information matrix to which this FisherBlock belongs.
params: The parameters (Tensor or tuple of Tensors) of this layer. If
kernel alone, a Tensor of shape [kernel_height, kernel_width,
in_channels, out_channels]. If kernel and bias, a tuple of 2 elements
containing the previous and a Tensor of shape [out_channels].
inputs: A Tensor of shape [batch_size, height, width, in_channels].
Input activations to this layer.
outputs: A Tensor of shape [batch_size, height, width, out_channels].
Output pre-activations from this layer.
strides: The stride size in this layer (1-D Tensor of length 4).
padding: The padding in this layer (1-D of Tensor length 4).
"""
self._inputs = inputs
self._outputs = outputs
self._strides = strides
self._padding = padding
self._has_bias = isinstance(params, (tuple, list))
fltr = params[0] if self._has_bias else params
self._filter_shape = tuple(fltr.shape.as_list())
input_shape = tuple(inputs.shape.as_list())
self._num_locations = (input_shape[1] * input_shape[2]
// (strides[1] * strides[2]))
super(ConvDiagonalFB, self).__init__(layer_collection)
def instantiate_factors(self, grads_list, damping):
if NORMALIZE_DAMPING_POWER:
damping /= self._num_locations ** NORMALIZE_DAMPING_POWER
self._damping = damping
self._factor = self._layer_collection.make_or_get_factor(
fisher_factors.ConvDiagonalFactor,
(self._inputs, grads_list, self._filter_shape, self._strides,
self._padding, self._has_bias))
def multiply_inverse(self, vector):
reshaped_vect = utils.layer_params_to_mat2d(vector)
reshaped_out = reshaped_vect / (self._factor.get_cov() + self._damping)
return utils.mat2d_to_layer_params(vector, reshaped_out)
def multiply(self, vector):
reshaped_vect = utils.layer_params_to_mat2d(vector)
reshaped_out = reshaped_vect * (self._factor.get_cov() + self._damping)
return utils.mat2d_to_layer_params(vector, reshaped_out)
def tensors_to_compute_grads(self):
return self._outputs
class KroneckerProductFB(FisherBlock):
"""A base class for FisherBlocks with separate input and output factors.
The Fisher block is approximated as a Kronecker product of the input and
output factors.
"""
def _register_damped_input_and_output_inverses(self, damping):
"""Registers damped inverses for both the input and output factors.
Sets the instance members _input_damping and _output_damping. Requires the
instance members _input_factor and _output_factor.
Args:
damping: The base damping factor (float or Tensor) for the damped inverse.
"""
pi = utils.compute_pi(self._input_factor.get_cov(),
self._output_factor.get_cov())
self._input_damping = math_ops.sqrt(damping) * pi
self._output_damping = math_ops.sqrt(damping) / pi
self._input_factor.register_damped_inverse(self._input_damping)
self._output_factor.register_damped_inverse(self._output_damping)
@property
def _renorm_coeff(self):
return 1.0
def multiply_inverse(self, vector):
left_factor_inv = self._input_factor.get_inverse(self._input_damping)
right_factor_inv = self._output_factor.get_inverse(self._output_damping)
reshaped_vector = utils.layer_params_to_mat2d(vector)
reshaped_out = math_ops.matmul(left_factor_inv,
math_ops.matmul(reshaped_vector,
right_factor_inv))
if self._renorm_coeff != 1.0:
reshaped_out /= math_ops.cast(
self._renorm_coeff, dtype=reshaped_out.dtype)
return utils.mat2d_to_layer_params(vector, reshaped_out)
def multiply(self, vector):
left_factor = self._input_factor.get_cov()
right_factor = self._output_factor.get_cov()
reshaped_vector = utils.layer_params_to_mat2d(vector)
reshaped_out = (math_ops.matmul(reshaped_vector, right_factor) +
self._output_damping * reshaped_vector)
reshaped_out = (math_ops.matmul(left_factor, reshaped_out) +
self._input_damping * reshaped_out)
if self._renorm_coeff != 1.0:
reshaped_out *= math_ops.cast(
self._renorm_coeff, dtype=reshaped_out.dtype)
return utils.mat2d_to_layer_params(vector, reshaped_out)
def full_fisher_block(self):
"""Explicitly constructs the full Fisher block.
Used for testing purposes. (In general, the result may be very large.)
Returns:
The full Fisher block.
"""
left_factor = self._input_factor.get_cov()
right_factor = self._output_factor.get_cov()
return self._renorm_coeff * utils.kronecker_product(left_factor,
right_factor)
class FullyConnectedKFACBasicFB(KroneckerProductFB):
"""K-FAC FisherBlock for fully-connected (dense) layers.
This uses the Kronecker-factorized approximation from the original
K-FAC paper (path_to_url
"""
def __init__(self, layer_collection, inputs, outputs, has_bias=False):
"""Creates a FullyConnectedKFACBasicFB block.
Args:
layer_collection: The collection of all layers in the K-FAC approximate
Fisher information matrix to which this FisherBlock belongs.
inputs: The Tensor of input activations to this layer.
outputs: The Tensor of output pre-activations from this layer.
has_bias: Whether the component Kronecker factors have an additive bias.
(Default: False)
"""
self._inputs = inputs
self._outputs = outputs
self._has_bias = has_bias
super(FullyConnectedKFACBasicFB, self).__init__(layer_collection)
def instantiate_factors(self, grads_list, damping):
self._input_factor = self._layer_collection.make_or_get_factor(
fisher_factors.FullyConnectedKroneckerFactor, ((self._inputs,),
self._has_bias))
self._output_factor = self._layer_collection.make_or_get_factor(
fisher_factors.FullyConnectedKroneckerFactor, (grads_list,))
self._register_damped_input_and_output_inverses(damping)
def tensors_to_compute_grads(self):
return self._outputs
class ConvKFCBasicFB(KroneckerProductFB):
"""FisherBlock for 2D convolutional layers using the basic KFC approx.
See path_to_url for details.
"""
def __init__(self, layer_collection, params, inputs, outputs, strides,
padding):
"""Creates a ConvKFCBasicFB block.
Args:
layer_collection: The collection of all layers in the K-FAC approximate
Fisher information matrix to which this FisherBlock belongs.
params: The parameters (Tensor or tuple of Tensors) of this layer. If
kernel alone, a Tensor of shape [kernel_height, kernel_width,
in_channels, out_channels]. If kernel and bias, a tuple of 2 elements
containing the previous and a Tensor of shape [out_channels].
inputs: A Tensor of shape [batch_size, height, width, in_channels].
Input activations to this layer.
outputs: A Tensor of shape [batch_size, height, width, out_channels].
Output pre-activations from this layer.
strides: The stride size in this layer (1-D Tensor of length 4).
padding: The padding in this layer (1-D of Tensor length 4).
"""
self._inputs = inputs
self._outputs = outputs
self._strides = strides
self._padding = padding
self._has_bias = isinstance(params, (tuple, list))
fltr = params[0] if self._has_bias else params
self._filter_shape = tuple(fltr.shape.as_list())
input_shape = tuple(inputs.shape.as_list())
self._num_locations = (input_shape[1] * input_shape[2] //
(strides[1] * strides[2]))
super(ConvKFCBasicFB, self).__init__(layer_collection)
def instantiate_factors(self, grads_list, damping):
self._input_factor = self._layer_collection.make_or_get_factor(
fisher_factors.ConvInputKroneckerFactor,
(self._inputs, self._filter_shape, self._strides, self._padding,
self._has_bias))
self._output_factor = self._layer_collection.make_or_get_factor(
fisher_factors.ConvOutputKroneckerFactor, (grads_list,))
if NORMALIZE_DAMPING_POWER:
damping /= self._num_locations**NORMALIZE_DAMPING_POWER
self._register_damped_input_and_output_inverses(damping)
@property
def _renorm_coeff(self):
return self._num_locations
def tensors_to_compute_grads(self):
return self._outputs
```
|
```smalltalk
using System.Windows;
using System.Windows.Interop;
namespace ScreenToGif.Util;
public class ScreenHelper
{
public static System.Windows.Forms.Screen GetScreen(Window window)
{
return System.Windows.Forms.Screen.FromHandle(new WindowInteropHelper(window).Handle);
}
}
```
|
The 1983 Calgary Stampeders season was the 39th season for the Canadian Football League club. They finished in 4th place in the West Division with an 8–8 record and failed to make the playoffs.
Regular season
The Stampeders' 1983 season is best remembered for an upset loss at home completed in the last three minutes of the campaign that not only kept them out of the playoffs, but deprived Calgary of an opportunity to dethrone their bitter archrivals who were the five-time defending Grey Cup champions.
Calgary entered the final week of the season with an 8-7 record and were in third place in the West. The Edmonton Eskimos, despite being five-time defending champions, had struggled to an 8-8 record and were idle in the final week. With the cross-over rule not yet in effect, the Eskimos could thus only watch helplessly as their provincial rivals hosted the long-eliminated 4-11 Saskatchewan Roughriders needing only a tie to end Edmonton's season. Crucially however, Edmonton held any potential tiebreaker over Calgary on account of a slim advantage in points-for-and-against ratio in divisional games, thus ensuring Calgary would miss the playoffs with a loss by any margin.
Calgary stormed to an early 12-0 lead in the first quarter, but Saskatchewan came back and eventually tied the game 20-20 by the end of the third quarter. In the fourth quarter, the Stampeders scored three consecutive singles, the last of these coming with just 2:45 left on the clock. Since no overtime format was yet in force for the CFL regular season, Calgary at that point only needed to hold Saskatchewan to a field goal to reach the postseason. On their next possession however, the Stampeders turned the ball over on their own 43-yard line when a third-down snap bounced off the turf and was fumbled by punter Mike McTague. On their ensuing drive, which crucially included a successful third-and-eleven conversion from well within the field goal range of Saskatchewan kicker Dave Ridgway, the Roughriders scored a touchdown with 27 seconds remaining in the game. They then held off a final desperate Calgary drive to shock the Stampeders and their fans, 27-23, thus ending Calgary's season.
Ultimately however, the Stampeders' miscue extended the their rivals' dynasty by only one week as the Eskimos were throttled 49-22 by the Winnipeg Blue Bombers in the Western Semi-Final.
Season standings
Season schedule
Awards and records
1983 CFL All-Stars
LB – Danny Bass, CFL All-Star
DB – Richard Hall, CFL All-Star
References
Calgary Stampeders seasons
1983 Canadian Football League season by team
|
```java
package com.dexvis.util;
import java.sql.Timestamp;
/**
* This class provides time related utilities.
*
* @author Patrick E. Martin
* @version 1.0
*
**/
public class SqlTimeFactory
{
/**
*
* This routine returns a timestamp containing the current time.
*
* @return A Timestamp containing the current time as known
* by the machine on which this routine is called.
*
**/
public static Timestamp currentTime()
{
return new Timestamp((new java.util.Date()).getTime());
}
/**
*
* This routine returns a timestamp containing the current time offset
* by a specified number of milliseconds.
*
* @param offset The number of milliseconds to offset this time by.
*
* @return A Timestamp containing the current time offset
* by the given offset. Current time is the current time
* as known by the machine on which this routine is called.
*
**/
public static Timestamp relativeTime(long offset)
{
return new Timestamp((new java.util.Date()).getTime() + offset);
}
/**
*
* This is a convenience function to convert a java.util.date to a
* Timestamp.
*
* @param date The date to convert.
*
* @return A Timestamp equivalent to the given date.
*
**/
public static Timestamp date2Timestamp(java.util.Date date)
{
//return new Timestamp(date.getYear(), date.getMonth(),
// date.getDate(), date.getHours(),
// date.getMinutes(), date.getSeconds(), 0);
return new Timestamp(date.getTime());
}
}
```
|
Brzeźniak may refer to the following places:
Brzeźniak, Greater Poland Voivodeship (west-central Poland)
Brzeźniak, West Pomeranian Voivodeship (north-west Poland)
Brzeźniak, Wałcz County in West Pomeranian Voivodeship (north-west Poland)
|
```c++
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing,
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// specific language governing permissions and limitations
#include "statestore/statestore-catalogd-mgr.h"
#include "gen-cpp/Types_types.h"
#include "util/container-util.h"
#include "util/time.h"
using namespace impala;
DECLARE_bool(use_subscriber_id_as_catalogd_priority);
DECLARE_int64(catalogd_ha_preemption_wait_period_ms);
#define COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(NAME1, NAME2) \
do { \
NAME1##_catalogd_subscriber_id_ = NAME2##_catalogd_subscriber_id_; \
NAME1##_catalogd_registration_id_ = NAME2##_catalogd_registration_id_; \
NAME1##_catalogd_registration_ = NAME2##_catalogd_registration_; \
} while (false)
#define COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(NAME) \
do { \
NAME##_catalogd_subscriber_id_ = subscriber_id; \
NAME##_catalogd_registration_id_ = registration_id; \
NAME##_catalogd_registration_ = catalogd_registration; \
} while (false)
#define RESET_CATALOGD_REGISTRATION_MEMBER_VARIABLES(NAME) \
do { \
NAME##_catalogd_subscriber_id_ = ""; \
NAME##_catalogd_registration_id_ = TUniqueId(); \
NAME##_catalogd_registration_ = TCatalogRegistration(); \
} while (false)
bool StatestoreCatalogdMgr::RegisterCatalogd(bool is_reregistering,
const SubscriberId& subscriber_id,
const RegistrationId& registration_id,
const TCatalogRegistration& catalogd_registration) {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
if (!enable_catalogd_ha_) {
// CatalogD HA is not enabled.
if (!is_reregistering) num_registered_catalogd_++;
DCHECK(num_registered_catalogd_ < 2);
is_active_catalogd_assigned_ = true;
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(active);
++active_catalogd_version_;
last_update_catalogd_time_ = UnixMillis();
return true;
}
if (is_reregistering) {
if (num_registered_catalogd_ == 2) {
DCHECK(is_active_catalogd_assigned_);
if (subscriber_id == standby_catalogd_subscriber_id_
&& catalogd_registration.force_catalogd_active) {
// Re-register standby catalogd as active one.
COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(standby, active);
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(active);
LOG(INFO) << active_catalogd_subscriber_id_
<< " is re-registered with FLAGS_force_catalogd_active.";
++active_catalogd_version_;
last_update_catalogd_time_ = UnixMillis();
return true;
}
} else {
DCHECK(num_registered_catalogd_ == 1 && first_catalogd_register_time_ != 0);
if (!is_active_catalogd_assigned_
&& (MonotonicMillis() - first_catalogd_register_time_
>= FLAGS_catalogd_ha_preemption_wait_period_ms)) {
is_active_catalogd_assigned_ = true;
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(active);
LOG(INFO) << active_catalogd_subscriber_id_
<< " is re-registered after HA preemption waiting period and "
<< "is assigned as active catalogd.";
++active_catalogd_version_;
last_update_catalogd_time_ = UnixMillis();
return true;
}
}
// There is no role change during re-registration.
VLOG(3) << subscriber_id << " is re-registered, but there is no role change.";
return false;
}
if (num_registered_catalogd_ == 0) {
DCHECK(!is_active_catalogd_assigned_);
// First catalogd is registered.
num_registered_catalogd_++;
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(first);
bool is_waiting_period_expired = false;
if (first_catalogd_register_time_ == 0) {
first_catalogd_register_time_ = MonotonicMillis();
if (FLAGS_catalogd_ha_preemption_wait_period_ms == 0) {
is_waiting_period_expired = true;
}
} else if (MonotonicMillis() - first_catalogd_register_time_ >=
FLAGS_catalogd_ha_preemption_wait_period_ms) {
is_waiting_period_expired = true;
}
if (catalogd_registration.force_catalogd_active || is_waiting_period_expired) {
// Don't need to wait second catalogd if force_catalogd_active is true or the
// waiting period is expired.
is_active_catalogd_assigned_ = true;
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(active);
LOG(INFO) << active_catalogd_subscriber_id_ << " is assigned as active catalogd.";
++active_catalogd_version_;
last_update_catalogd_time_ = UnixMillis();
return true;
}
// Wait second catalogd to be registered.
VLOG(3) << "Wait second catalogd to be registered during HA preemption waiting "
<< "period.";
} else {
num_registered_catalogd_++;
DCHECK(num_registered_catalogd_ == 2)
<< "No more than 2 CatalogD registrations are allowed!";
if (catalogd_registration.force_catalogd_active) {
// Force to set the current one as active catalogd
if (is_active_catalogd_assigned_) {
COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(standby, active);
} else {
COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(standby, first);
}
is_active_catalogd_assigned_ = true;
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(active);
LOG(INFO) << active_catalogd_subscriber_id_
<< " is registered with FLAGS_force_catalogd_active and is assigned as "
<< "active catalogd.";
++active_catalogd_version_;
last_update_catalogd_time_ = UnixMillis();
return true;
} else if (is_active_catalogd_assigned_) {
// Existing one is already assigned as active catalogd.
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(standby);
VLOG(3) << "There is another catalogd already assigned as active catalogd.";
} else {
// Compare priority and assign the catalogd with high priority as active catalogd.
is_active_catalogd_assigned_ = true;
bool first_has_high_priority = FLAGS_use_subscriber_id_as_catalogd_priority
? first_catalogd_subscriber_id_ < subscriber_id
: first_catalogd_registration_id_ < registration_id;
if (first_has_high_priority) {
COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(active, first);
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(standby);
} else {
COPY_CATALOGD_REGISTRATION_FROM_LOCAL_VARIABLES(active);
COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(standby, first);
}
LOG(INFO) << active_catalogd_subscriber_id_
<< " has higher priority and is assigned as active catalogd.";
++active_catalogd_version_;
last_update_catalogd_time_ = UnixMillis();
return true;
}
}
return false;
}
bool StatestoreCatalogdMgr::CheckActiveCatalog() {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
if (is_active_catalogd_assigned_) {
return true;
} else if (num_registered_catalogd_ == 0
|| first_catalogd_register_time_ == 0
|| (MonotonicMillis() - first_catalogd_register_time_ <
FLAGS_catalogd_ha_preemption_wait_period_ms)) {
return false;
}
// Assign the first registered catalogd as active one.
DCHECK(num_registered_catalogd_ == 1);
is_active_catalogd_assigned_ = true;
COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(active, first);
LOG(INFO) << active_catalogd_subscriber_id_
<< " is assigned as active catalogd after preemption waiting period.";
++active_catalogd_version_;
last_update_catalogd_time_ = UnixMillis();
return true;
}
bool StatestoreCatalogdMgr::UnregisterCatalogd(
const SubscriberId& unregistered_subscriber_id) {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
num_registered_catalogd_--;
if (unregistered_subscriber_id == active_catalogd_subscriber_id_) {
// Unregister active catalogd.
DCHECK(is_active_catalogd_assigned_);
if (num_registered_catalogd_ > 0) {
// Fail over to standby catalogd
COPY_CATALOGD_REGISTRATION_FROM_MEMBER_VARIABLES(active, standby);
RESET_CATALOGD_REGISTRATION_MEMBER_VARIABLES(standby);
LOG(INFO) << "Fail over active catalogd to " << active_catalogd_subscriber_id_;
last_update_catalogd_time_ = UnixMillis();
++active_catalogd_version_;
return true;
} else {
is_active_catalogd_assigned_ = false;
// Don't need to wait second one to be registered.
first_catalogd_register_time_ = MonotonicMillis() -
FLAGS_catalogd_ha_preemption_wait_period_ms -1;
LOG(INFO) << "No active catalogd available in the cluster";
}
} else if (num_registered_catalogd_ > 0) {
// Unregister standby catalogd.
DCHECK(unregistered_subscriber_id == standby_catalogd_subscriber_id_);
RESET_CATALOGD_REGISTRATION_MEMBER_VARIABLES(standby);
VLOG(3) << "Unregister standby catalogd " << unregistered_subscriber_id;
} else {
// Active catalogd has not been designated.
DCHECK(!is_active_catalogd_assigned_);
}
return false;
}
const TCatalogRegistration& StatestoreCatalogdMgr::GetActiveCatalogRegistration(
bool* has_active_catalogd, int64_t* active_catalogd_version) {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
*has_active_catalogd = is_active_catalogd_assigned_;
*active_catalogd_version = active_catalogd_version_;
return active_catalogd_registration_;
}
const TCatalogRegistration& StatestoreCatalogdMgr::GetStandbyCatalogRegistration() {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
return standby_catalogd_registration_;
}
const SubscriberId& StatestoreCatalogdMgr::GetActiveCatalogdSubscriberId() {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
return active_catalogd_subscriber_id_;
}
bool StatestoreCatalogdMgr::IsActiveCatalogd(const SubscriberId& subscriber_id) {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
return active_catalogd_subscriber_id_ == subscriber_id;
}
int64_t StatestoreCatalogdMgr::GetLastUpdateCatalogTime() {
std::lock_guard<std::mutex> l(catalog_mgr_lock_);
return last_update_catalogd_time_;
}
```
|
The Declaration of Helsinki from the Global Cities Dialogue is the set of principles and commitments that define the purpose of the organisation - an international grouping of over 100 cities whose representatives:
"...believe that the development of the Information Society should be for the benefit of all their citizens, communities, and peoples of the world, regardless of race, social position, creed, gender or age...."
See also
Digital divide
World Summit on the Information Society
Digital rights
References
Digital divide
Information and communication technologies for development
Rights
|
Friedrich Gottlieb Barth (3 August 1738 – 6 October 1794) was a German philologist and writer.
He was born in Wittenberg, the son of Johann Christian Barth and his wife Catarina Elisabeth (née Krause).
1738 births
1794 deaths
People from Wittenberg
People from the Electorate of Saxony
German philologists
Writers from Saxony-Anhalt
German male writers
|
```c++
#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// common_iarchive.hpp
// Use, modification and distribution is subject to the Boost Software
// path_to_url
// See path_to_url for updates, documentation, and revision history.
#include <boost/config.hpp>
#include <boost/archive/detail/basic_iarchive.hpp>
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
#include <boost/archive/detail/interface_iarchive.hpp>
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable : 4511 4512)
#endif
namespace boost {
namespace archive {
namespace detail {
class extended_type_info;
// note: referred to as Curiously Recurring Template Patter (CRTP)
template<class Archive>
class BOOST_SYMBOL_VISIBLE common_iarchive :
public basic_iarchive,
public interface_iarchive<Archive>
{
friend class interface_iarchive<Archive>;
friend class basic_iarchive;
private:
void vload(version_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
void vload(object_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
void vload(class_id_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
void vload(class_id_optional_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
void vload(tracking_type & t) BOOST_OVERRIDE {
* this->This() >> t;
}
void vload(class_name_type &s) BOOST_OVERRIDE {
* this->This() >> s;
}
protected:
// default processing - invoke serialization library
template<class T>
void load_override(T & t){
archive::load(* this->This(), t);
}
// default implementations of functions which emit start/end tags for
// archive types that require them.
void load_start(const char * /*name*/){}
void load_end(const char * /*name*/){}
// default archive initialization
common_iarchive(unsigned int flags = 0) :
basic_iarchive(flags),
interface_iarchive<Archive>()
{}
};
} // namespace detail
} // namespace archive
} // namespace boost
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
```
|
```javascript
var Faker = require('../lib');
var faker = new Faker({ locale: 'en', localeFallback: 'en' });
faker.locales['en'] = require('../lib/locales/en');
faker.locales['en'] = require('../lib/locales/en');
module['exports'] = faker;
```
|
Habibi (foaled 4 September 2009) is a New Zealand thoroughbred racehorse. She is most noted for winning the 2013 New Zealand Derby; one of only five fillies since 1980 to achieve this feat. She is trained by Donna and Dean Logan.
Habibi made her raceday debut in October 2012, winning at her home track of Ruakaka. Wins at Avondale and Ellerslie followed, before she was asked to take on the top male three-year-olds over the Ellerslie Christmas Carnival. This decision proved successful, with Habibi easily winning both the Great Northern Guineas on Boxing Day and the Championship Stakes on New Year's Day. These wins made her unbeaten in five starts, and saw her become a clear favourite for the New Zealand Derby. A solid run for third in the Avondale Guineas was her only subsequent lead-up run to the Derby. In the Derby, she started from the inside barrier, settled four-back on the rail before getting clear in the straight and running down another filly, Fix, for a half-length win. The victory gave rider Vinnie Colgan his fifth success in the New Zealand Derby, the most of any rider since the race was moved to Ellerslie in 1973.
See also
2013 New Zealand Derby
Thoroughbred racing in New Zealand
References
Racehorses bred in New Zealand
Racehorses trained in New Zealand
2009 racehorse births
Thoroughbred family 14-b
|
```objective-c
/*
*
*/
/* PDU_ANTENNA is defined outside of the #if block below because
* radio_df_pdu_antenna_switch_pattern_get() can get called even when
* the preprocessor condition being tested is 0. In this case, we use
* the default value of 0.
*/
#define PDU_ANTENNA DT_PROP_OR(RADIO_NODE, dfe_pdu_antenna, 0)
/* Function configures Radio with information about GPIO pins that may be
* used to drive antenna switching during CTE Tx/RX.
*/
void radio_df_ant_switching_pin_sel_cfg(void);
/* Configures GPIO pins in GPIO peripheral. The pins will be used for antenna
* switching during CTE Rx/Tx.
*/
void radio_df_ant_switching_gpios_cfg(void);
/* Provides number of available antennas for Direction Finding. */
uint8_t radio_df_ant_num_get(void);
/* Sets Direction Finding AOA mode. */
void radio_df_mode_set_aoa(void);
/* Sets Direction Finding AOD mode. */
void radio_df_mode_set_aod(void);
/* Configure CTE transmission with 2us antenna switching for AoD. */
void radio_df_cte_tx_aod_2us_set(uint8_t cte_len);
/* Configure CTE transmission with 4us antenna switching for AoD. */
void radio_df_cte_tx_aod_4us_set(uint8_t cte_len);
/* Configure CTE transmission with for AoA. */
void radio_df_cte_tx_aoa_set(uint8_t cte_len);
/* Configure CTE reception with optional AoA mode and 2us antenna switching. */
void radio_df_cte_rx_2us_switching(bool cte_info_in_s1, uint8_t phy);
/* Configure CTE reception with optional AoA mode and 4us antenna switching. */
void radio_df_cte_rx_4us_switching(bool cte_info_in_s1, uint8_t phy);
/* Clears antenna switch pattern. */
void radio_df_ant_switch_pattern_clear(void);
/* Set antenna switch pattern. Pay attention, patterns are added to
* Radio internal list. Before start of new patterns clear the list
* by call to @ref radio_df_ant_switch_pattern_clear.
*/
void radio_df_ant_switch_pattern_set(const uint8_t *patterns, uint8_t len);
/* Provides switch pattern of antenna used to transmit PDU that is used to
* transmit CTE
*/
uint8_t radio_df_pdu_antenna_switch_pattern_get(void);
/* Resets Direction Finding radio configuration */
void radio_df_reset(void);
/* Completes switching and enables shortcut between PHYEND and TXEN events */
void radio_switch_complete_and_phy_end_b2b_tx(uint8_t phy_curr, uint8_t flags_curr,
uint8_t phy_next, uint8_t flags_next);
/* Set buffer to store IQ samples collected during CTE sampling */
void radio_df_iq_data_packet_set(uint8_t *buffer, size_t len);
/* Get number of stored IQ samples during CTE receive */
uint32_t radio_df_iq_samples_amount_get(void);
/* Get CTE status (CTEInfo) parsed by Radio from received PDU */
uint8_t radio_df_cte_status_get(void);
/* Get information if CTE was present in a received packet */
bool radio_df_cte_ready(void);
```
|
Nagendra Rae Yadav or Nagendra Raya Yadav () is a Nepalese politician belonging to CPN (Unified Socialist). He is also serving as member of Provincial Assembly of Madhesh Province.
He is currently serving as Minister of state for Industry, Tourism and Forest of Madhesh Province under minister Satrudhan Mahato.
Electoral history
2017 Nepalese provincial elections
See also
CPN (Unified Socialist)
Ram Chandra Jha
Bansidhar Mishra
Satrudhan Mahato
References
Communist Party of Nepal (Unified Socialist) politicians
Year of birth missing (living people)
Living people
Provincial cabinet ministers of Nepal
Members of the Provincial Assembly of Madhesh Province
Communist Party of Nepal (Unified Marxist–Leninist) politicians
|
This is a list consisting of the deadliest floods worldwide with a minimum of 60 deaths.
List
Floods by year
Only floods having caused 10 fatalities or more in 21st-century are listed.
2023
2022
2021
2020
2019
2018
2017
2016
2015
2014
2013
2012
2011
2010
2009
2008
2007
2006
2005
2004
2003
2002
2001
2000
Notes
1.Some reports list as many as 12,000 dead.
See also
List of floods
List of flash floods
List of natural disasters by death toll
References
External links
Global Active Archive of Large Flood Events, Dartmouth Flood Observatory
Deadliest
Floods
|
Inside the Death Squad or 'Death squad': Inside Bangladesh's Rapid Action Battalion is a documentary film produced by Deutsche Welle in partnership with Netra News that investigates allegations of extrajudicial killings and human rights abuses committed by the Rapid Action Battalion (RAB), an elite police force in Bangladesh. The documentary features interviews with former RAB officers, witnesses, and human rights activists, and includes footage of alleged killings and interviews with family members of victims. The RAB has been accused of carrying out extrajudicial killings and human rights abuses in Bangladesh. The documentary sheds light on the tactics used by the RAB, including torture, enforced disappearances, and extrajudicial killings, and raises important questions about the use of state violence and the government's role in protecting human rights.
Background
The Rapid Action Battalion (RAB) was established on July 12, 2003, through the Armed Police Battalion (Amendment) Act, 2003. Between 2004 and 2008, RAB was responsible for the deaths of 1,062 individuals. Human Rights Watch has accused RAB of numerous deaths that have been attributed to crossfire. In March 2010, the RAB leader claimed that 622 deaths were due to crossfire, while some human rights organizations maintained that the battalion was responsible for more than 1,000 extrajudicial killings. There have also been numerous reports of torture associated with the battalion's activities. According to Human Rights Watch, members of RAB have shot and killed women and children during public protests, leading some to describe it as a "death squad."
According to a report by human rights organization Ain o Salish Kendra (ASK), families of victims and witnesses blamed RAB for the disappearance of 83 people, while the detective branch was blamed for 38, "law enforcers" for 55, and plainclothes men for 20 others between January 2007 and August 2014.
On October 27, 2020, the United States Senate Foreign Relations Committee wrote a letter to the United States Secretary of State and the United States Secretary of the Treasury, urging them to impose sanctions on senior officials of the Rapid Action Battalion for their human rights violations. On December 10, 2021, the U.S. Department of the Treasury added RAB to its Specially Designated Nationals (SDN) list under GLOMAG. Additionally, six individuals associated with RAB, including its Director General Chowdhury Abdullah Al-Mamun, former DG Benazir Ahmed, and ADG Colonel KM Azad, were sanctioned. Entities on the list have their assets blocked, and U.S. persons are generally prohibited from dealing with them.
Content
The documentary alleges that the Rapid Action Battalion (RAB) has been involved in extrajudicial killings, enforced disappearances, and the torture of suspects. It provides several examples of alleged human rights abuses committed by the RAB, including the case of a man who was reportedly tortured to death while in RAB custody. The documentary also cites reports by human rights organizations that have accused the RAB of carrying out "crossfire" killings, which are allegedly staged encounters with suspects that result in their deaths. The documentary includes interviews with activists and experts who have criticized the RAB's tactics and called for its abolition. It also features interviews with two former leaders of the RAB, who admit to wrongdoing.
Reaction
On April 7, 2023, the United States announced that it will review the allegations made against the Rapid Action Battalion (RAB) in the documentary. However, the Foreign Minister of Bangladesh, AK Abdul Momen, dismissed the documentary and made a comment that it was funny.
References
External links
DW documentaries
2023 documentary films
2023 films
Rapid Action Battalion
Documentary films about Bangladesh
Political scandals in Bangladesh
2020s English-language films
2023 YouTube videos
|
Mohammed Tahir was a Pakistani police officer who served as the Inspector General of Police in Punjab. Prior to his appointment as IG for Punjab, he served as IG Khyber Pakhtunkhwa. A 16th batch of civil services, he originally joined police service in 1988 as an assistant superintendent.
References
Pakistani police officers
Living people
Pashtun police officers
Year of birth missing (living people)
|
The Auteurs were a British alternative rock band of the 1990s, and a vehicle for songwriter Luke Haines (guitar, piano and vocals). Several bands influenced by the Auteurs have taken their names from the band's songs. The Polish band Lenny Valentino took its name from the Auteurs' song on their album Now I'm a Cowboy and the Minneapolis based band Valet took its name from the song "Valet Parking" from New Wave.
History
Formerly a member of the Servants, Haines created the Auteurs with his then-girlfriend Alice Readman on bass guitar, former classmate Glenn Collins on drums, and later added James Banbury on cello.
The Auteurs demo tape and gig led to the band gaining a recording contract with Hut. Their first single "Show Girl" was praised by the British music magazine Melody Maker and the album New Wave (1993) was nominated for a Mercury Music Prize. The Auteurs later became associated with the Britpop movement. However this association was not liked by Haines, who frequently made derogatory remarks about his peers. After New Wave, the band remained on the fringes of the music scene. Drummer Glen Collins was replaced by Barny C. Rockford, after being headhunted from Out of My Hair by producer Phil Vinall. Their next album Now I'm a Cowboy (1994), built on the themes of New Wave and contained Haines' best known song, "Lenny Valentino". Demonstrating, again, their difference from their musical peers, the band's next release was The Auteurs vs. μ-Ziq, Auteurs songs remixed by producer µ-Ziq (aka Michael Paradinas). In interviews at the time Haines claimed he found contemporary techno and house music more interesting than most Britpop bands.
In 1996, The Auteurs released After Murder Park, produced by Steve Albini, and it included "Land Lovers", "Unsolved Child Murder", and "Buddha". The album was recorded at Abbey Road Studios following a year during which Haines had spent most of his time in a wheelchair after jumping off a wall. Haines made the Baader Meinhof album as a solo artist under the name Baader Meinhof, using some musicians from the Auteurs. The Auteurs supported Baader Meinhof at a London show in Camden's Dingwalls. The last Auteurs record, How I Learned to Love the Bootboys, was released in 1999. Alice Readman left the band around the time of the last album, and was replaced by various musicians for live/touring purposes.
Post-Breakup
Haines worked as one third of the art-pop band Black Box Recorder. In 2001 he released the soundtrack album to the film Christie Malry's Own Double-Entry, rapidly followed by his first solo album proper, The Oliver Twist Manifesto. 2003 saw him release Das Capital, a collection of re-recorded Auteurs era songs, with a couple of new tracks, apparently intended as closure for that band.
Banbury went on to record an album with Paul Morley under the name Infantjoy, entitled Where the Night Goes featuring a vocal performance by Sarah Nixey of Black Box Recorder singing a version of Japan's "Ghosts". An Infantjoy album – With – was released in 2006 with collaborators including Tunng, Isan and Populous.
In January 2009, Haines released a book entitled Bad Vibes, which serves dually as an autobiographical account of his years with the Auteurs, and as a record of the Britpop movement of the 1990s. Throughout the book, he never refers to James Banbury by name, referring to him simply as "the Cellist", although he is named in full in the acknowledgements. Banbury later worked with Pete Davis under the name Dadahack. Their debut album TAP3 was a hybrid cassette/mp3 playing device and was released in April 2010.
In 2014, British independent label 3 Loop Music re-released all of the Auteurs' albums (along with Haines' "Baader Meinhoff" album) as expanded editions which featured b-sides, demos, radio session tracks, live recordings and remixes. New Wave and Baader Meinhoff were also re-released by the label on heavyweight 180gsm vinyl.
Members
Luke Haines - guitar, piano, vocals (1991-1999)
Alice Readman - bass guitar (1991-1999)
Glenn Collins - drums (1991-1993)
James Banbury - cello, keyboards (1993-1999)
Barny C. Rockford - drums (1994-1999)
Discography
Studio albums
New Wave (1993) – UK No. 35
Now I'm a Cowboy (1994) – UK No. 27
After Murder Park (1996) – UK No. 53
How I Learned to Love the Bootboys (1999) – UK No. 114
EPs
Live Acoustic EP (1993)
The Auteurs Vs. µ-Ziq (remixes), (1994)
Back with the Killer (1995) – UK No. 45
Kids Issue (1996) – UK No. 163
Singles
"Show Girl" (1992)
"Housebreaker"/"Valet Parking" (1993)
"How Could I Be Wrong" (10 May 1993)
"New French Girlfriend" (1993)
"Lenny Valentino" (22 November 1993) – UK No. 41
"Chinese Bakery" (8 April 1994) – UK No. 42
"Light Aircraft on Fire" (9 February 1996) – UK No. 58
"The Rubettes" (5 July 1999) – UK No. 66
References
External links
Unofficial Auteurs web site
English indie rock groups
Britpop groups
Musical groups established in 1991
Musical groups disestablished in 1999
Luke Haines
1991 establishments in the United Kingdom
|
```cmake
vcpkg_download_distfile(ARCHIVE
URLS "path_to_url"
FILENAME "CCfits-2.5.tar.gz"
SHA512 your_sha256_hashyour_sha256_hash
)
vcpkg_extract_source_archive(
SOURCE_PATH
ARCHIVE "${ARCHIVE}"
PATCHES
dll_exports.patch
fix-dependency.patch
)
vcpkg_cmake_configure(
SOURCE_PATH "${SOURCE_PATH}"
OPTIONS
-DCMAKE_CXX_STANDARD=11 # 17 removes std::binary_function
)
vcpkg_cmake_install()
if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/bin")
file(RENAME "${CURRENT_PACKAGES_DIR}/lib/CCfits.dll" "${CURRENT_PACKAGES_DIR}/bin/CCfits.dll")
if(NOT VCPKG_BUILD_TYPE)
file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/debug/bin")
file(RENAME "${CURRENT_PACKAGES_DIR}/debug/lib/CCfits.dll" "${CURRENT_PACKAGES_DIR}/debug/bin/CCfits.dll")
endif()
endif()
# Remove duplicate include files
file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include")
# Patch installed headers to look in the correct subdirectory
file(GLOB HEADERS "${CURRENT_PACKAGES_DIR}/include/CCfits/*")
foreach(HEADER IN LISTS HEADERS)
vcpkg_replace_string("${HEADER}" "\"fitsio.h\"" "\"cfitsio/fitsio.h\"" IGNORE_UNCHANGED)
endforeach()
vcpkg_replace_string(${CURRENT_PACKAGES_DIR}/include/CCfits/CCfits.h
"#include \"longnam.h\"" "#include \"cfitsio/longnam.h\""
)
```
|
```lua
require('torch')
onmt = {}
onmt.utils = require('onmt.utils.init')
require('onmt.modules.init')
onmt.scorers = require('onmt.scorers.init')
onmt.data = require('onmt.data.init')
onmt.evaluators = require('onmt.evaluators.init')
onmt.train = require('onmt.train.init')
onmt.translate = require('onmt.translate.init')
onmt.tagger = require('onmt.tagger.init')
onmt.lm = require('onmt.lm.init')
onmt.Constants = require('onmt.Constants')
onmt.Factory = require('onmt.Factory')
onmt.Model = require('onmt.Model')
onmt.Seq2Seq = require('onmt.Seq2Seq')
onmt.LanguageModel = require('onmt.LanguageModel')
onmt.SeqTagger = require('onmt.SeqTagger')
onmt.ModelSelector = require('onmt.ModelSelector')
return onmt
```
|
Proceedings of the American Philosophical Society is a quarterly journal published by the American Philosophical Society since 1838. The journal contains papers which have been read at meetings of the American Philosophical Society each April and November, independent essays sent to the APS by outside scholars, and biographical memoirs of APS Members.
References
External links
Proceedings of the American Philosophical Society, Biodiversity Heritage Library
1838 establishments in the United States
Academic journals published by learned and professional societies
Publications established in 1838
Quarterly journals
|
```python
#!/usr/bin/env python3
#
# This software may be used and distributed according to the terms of the
# pyre-unsafe
import abc
import contextlib
import datetime
import json
import logging
import os
import re
import socket
import stat
import subprocess
import time
import types
import typing
from pathlib import Path
from typing import Any, Callable, Dict, Iterator, List, Optional, Type, TypeVar, Union
from eden.integration.lib import edenclient, hgrepo
from eden.integration.lib.temporary_directory import create_tmp_dir
from eden.test_support.temporary_directory import cleanup_tmp_dir
from . import inode_metadata as inode_metadata_mod, verify as verify_mod
T = TypeVar("T", bound="BaseSnapshot")
class BaseSnapshot(metaclass=abc.ABCMeta):
# The NAME and DESCRIPTION class fields are intended to be overridden on subclasses
# by the @snapshot_class decorator.
NAME = "Base Snapshot Class"
DESCRIPTION = ""
def __init__(self, base_dir: Path) -> None:
self.base_dir = base_dir
# All data inside self.data_dir will be saved as part of the snapshot
self.data_dir = self.base_dir / "data"
# Anything inside self.transient_dir will not be saved with the snapshot,
# and will always be regenerated from scratch when resuming a snapshot.
self.transient_dir = self.base_dir / "transient"
self.eden_state_dir = self.data_dir / "eden"
# We put the etc eden directory inside the transient directory.
# Whenever we resume a snapshot we want to use a current version of the edenfs
# daemon and its configuration, rather than an old copy of the edenfs
# configuration.
self.etc_eden_dir = self.transient_dir / "etc_eden"
# We put the home directory inside the transient directory as well.
self.home_dir = self.transient_dir / "home"
def __enter__(self: T) -> T:
return self
def __exit__(
self,
exc_type: Optional[Type[BaseException]],
exc_value: Optional[BaseException],
tb: Optional[types.TracebackType],
) -> None:
pass
def create_tarball(self, output_path: Path) -> None:
"""Create a tarball from the snapshot contents.
Note that in most cases you will likely want to save the snapshot state when
edenfs is not running, to ensure that the snapshot data is in a consistent
state.
"""
# Make sure the output directory exists
output_path.parent.mkdir(parents=True, exist_ok=True)
cmd = [
"gtar",
"-c",
"--auto-compress",
"--sort=name",
# The inode metadata table usually ends with quite a few empty pages.
# The --sparse flag allows tar to detect these and avoid emitting them.
# Given that we normally compress the result this doesn't really make
# much difference on the final compressed size, though.
"--sparse",
# Suppress warnings about the fact that tar skips Eden's socket files.
"--warning=no-file-ignored",
# The owner and group IDs in the tar file don't really matter.
# Just record a fixed data rather than pulling them from the
# current system being used to generate the archive.
"--owner=nobody:65534",
"--group=nobody:65534",
] + ["-f", str(output_path), "data"]
subprocess.check_call(cmd, cwd=self.base_dir)
def generate(self) -> None:
"""Generate the snapshot data.
This method should normally be called after constructing the snapshot object
pointing to an empty directory.
"""
self._create_directories()
self._emit_metadata()
self.gen_before_eden_running()
with self.edenfs() as eden:
eden.start()
self.gen_eden_running(eden)
self.gen_after_eden_stopped()
# Rewrite the config state to point to "/tmp/dummy_snapshot_path"
# This isn't really strictly necessary, but just makes the state that
# gets saved slightly more deterministic.
#
# Also update uid and gid information 99.
# This is commonly the UID & GID for "nobody" on many systems.
self._update_eden_state(Path("/tmp/dummy_snapshot_path"), uid=99, gid=99)
def verify(self, verifier: verify_mod.SnapshotVerifier) -> None:
"""Verify that the snapshot data looks correct.
This is generally invoked by tests to confirm that an unpacked snapshot still
works properly with the current version of EdenFS.
"""
with self.edenfs() as eden:
eden.start()
print("Verifing snapshot data:")
print("=" * 60)
self.verify_snapshot_data(verifier, eden)
print("=" * 60)
def edenfs(self) -> edenclient.EdenFS:
"""Return an EdenFS object that can be used to run an edenfs daemon for this
snapshot.
The returned EdenFS object will not be started yet; the caller must explicitly
call start() on it.
"""
return edenclient.EdenFS(
base_dir=self.transient_dir,
eden_dir=self.eden_state_dir,
etc_eden_dir=self.etc_eden_dir,
home_dir=self.home_dir,
storage_engine="rocksdb",
)
def resume(self) -> None:
"""Prepare a snapshot to be resumed after unpacking it.
This updates the snapshot data so it can be run from its new location,
and recreates any transient state needed for the snapshot.
"""
self.create_transient_dir()
self._update_hg_state(self.base_dir)
self._update_eden_state(self.base_dir, uid=os.getuid(), gid=os.getgid())
self.prep_resume()
def _create_directories(self) -> None:
self.data_dir.mkdir()
self.create_transient_dir()
def create_transient_dir(self) -> None:
self.transient_dir.mkdir()
self.etc_eden_dir.mkdir()
self.home_dir.mkdir()
def _emit_metadata(self) -> None:
now = time.time()
# In addition to recording the current time as a unix timestamp,
# we also store a tuple of (year, month, day). This is primarily to help make
# it easier for future verification code if we ever need to alter the
# verification logic for older versions of the same snapshot type.
# This will allow more human-readable time comparisons in the code, and makes it
# easier to compare just based on a prefix of this tuple.
now_date = datetime.datetime.fromtimestamp(now)
date_tuple = (
now_date.year,
now_date.month,
now_date.day,
now_date.hour,
now_date.minute,
now_date.second,
)
data = {
"type": self.NAME,
"description": self.DESCRIPTION,
"time_created": int(now),
"date_created": date_tuple,
"base_dir": str(self.base_dir),
}
self._write_metadata(data)
@property
def _metadata_path(self) -> Path:
return self.data_dir / "info.json"
def _write_metadata(self, data: Dict[str, Any]) -> None:
with self._metadata_path.open("w") as f:
json.dump(data, f, indent=2, sort_keys=True)
def _read_metadata(self) -> Dict[str, Any]:
with self._metadata_path.open("r") as f:
return typing.cast(Dict[str, Any], json.load(f))
def _update_hg_state(self, base_dir: Path) -> None:
"""Update hgrc so that it matches the location of the unpacked snapshot."""
hgrc_dir = self.data_dir / "repo/.hg/hgrc"
with hgrc_dir.open("r") as f:
match = re.search(r"\/tmp/eden_data\.\w+", f.read())
old_dir = match.group(0) if match is not None else None
if old_dir is not None:
self._replace_file_contents(hgrc_dir, bytes(Path(old_dir)), bytes(base_dir))
def _update_eden_state(self, base_dir: Path, uid: int, gid: int) -> None:
"""Update Eden's stored state for the snapshot so it will work in a new
location.
- Replace absolute path names in various data files to refer to the new
location. This is needed so that a snapshot originally created in one
location can be unpacked and used in another location.
- Update UID and GID values stored by Eden's to reflect the specified values.
This is needed so that unpacked snapshots can be used by the current user
without getting permissions errors when they try to access files inside the
Eden checkouts.
"""
info = self._read_metadata()
old_base_dir = Path(info["base_dir"])
# A few files in the RocksDB directory end up with the absolute path
# embedded in them.
rocks_db_path = self.eden_state_dir / "storage" / "rocks-db"
for entry in rocks_db_path.iterdir():
if entry.name.startswith("LOG") or entry.name.startswith("OPTIONS"):
self._replace_file_contents(entry, bytes(old_base_dir), bytes(base_dir))
# Parse eden's config.json to get the list of checkouts, and update each one.
eden_config_path = self.eden_state_dir / "config.json"
with eden_config_path.open("r+") as config_file:
eden_data = json.load(config_file)
new_config_data = {}
for _old_checkout_path, checkout_name in eden_data.items():
new_checkout_path = self.data_dir / checkout_name
new_config_data[str(new_checkout_path)] = checkout_name
checkout_state_dir = self.eden_state_dir / "clients" / checkout_name
self._relocate_checkout(checkout_state_dir, old_base_dir, base_dir)
self._update_ownership(checkout_state_dir, uid, gid)
config_file.seek(0)
config_file.truncate()
json.dump(new_config_data, config_file, indent=2, sort_keys=True)
# Update the info file with the new base path
info["base_dir"] = str(base_dir)
self._write_metadata(info)
def _update_ownership(self, checkout_state_dir: Path, uid: int, gid: int) -> None:
"""Update Eden's stored metadata about files to mark that files are owned by
the current user."""
metadata_path = checkout_state_dir / "local" / "metadata.table"
inode_metadata_mod.update_ownership(metadata_path, uid, gid)
def _relocate_checkout(
self, checkout_state_dir: Path, old_base_dir: Path, new_base_dir: Path
) -> None:
self._replace_file_contents(
checkout_state_dir / "config.toml", bytes(old_base_dir), bytes(new_base_dir)
)
overlay_dir = checkout_state_dir / "local"
self._relocate_overlay_dir(
overlay_dir, bytes(old_base_dir), bytes(new_base_dir)
)
def _relocate_overlay_dir(
self, dir_path: Path, old_data: bytes, new_data: bytes
) -> None:
# Recursively update the contents for every file in the overlay
# if it contains the old path.
#
# This approach is pretty dumb: we aren't processing the overlay file formats at
# all, just blindly replacing the contents if we happen to see something that
# looks like the old path. For now this is the easiest thing to do, and the
# chance of other data looking like the source path should be very unlikely.
#
# The following files typically contain absolute paths to the original
# snapshot location:
# .eden/root
# .eden/client
# .eden/socket
# .hg/sharedpath
#
# Everything in the .eden/ directory will be updated automatically by EdenFS
# when the checkout is mounted. Nonetheless it still seems good to update these
# files with a generic path after we shut down EdenFS when first generating the
# snapshot data.
#
for path in dir_path.iterdir():
stat_info = path.lstat()
if stat.S_ISDIR(stat_info.st_mode):
self._relocate_overlay_dir(path, old_data, new_data)
else:
self._replace_file_contents(path, old_data, new_data)
def _replace_file_contents(
self, path: Path, old_data: bytes, new_data: bytes
) -> None:
with path.open("rb+") as f:
file_contents = f.read()
new_contents = file_contents.replace(old_data, new_data)
if new_contents != file_contents:
f.seek(0)
f.truncate()
f.write(new_contents)
def gen_before_eden_running(self) -> None:
"""gen_before_eden_running() will be called when generating a new snapshot after
the directory structure has been set up but before edenfs is started.
Subclasses of BaseSnapshot can perform any work they want here.
"""
pass
def gen_eden_running(self, eden: edenclient.EdenFS) -> None:
"""gen_eden_running() will be called when generating a new snapshot once edenfs
has been started.
Subclasses of BaseSnapshot can perform any work they want here.
"""
pass
def gen_after_eden_stopped(self) -> None:
"""gen_after_eden_stopped() will be called as the final step of generating a
snapshot, once edenfs has been stopped.
Subclasses of BaseSnapshot can perform any work they want here.
"""
pass
def prep_resume(self) -> None:
"""prep_resume() will be when preparing to resume a snapshot, before edenfs has
been started.
Subclasses of BaseSnapshot can perform any work they want here.
here.
"""
pass
@abc.abstractmethod
def verify_snapshot_data(
self, verifier: verify_mod.SnapshotVerifier, eden: edenclient.EdenFS
) -> None:
"""Verify that the snapshot data looks correct.
This method should be overridden by subclasses.
"""
pass
class HgSnapshot(BaseSnapshot, metaclass=abc.ABCMeta):
"""A helper parent class for BaseSnapshot implementations that creates a single
checkout of a mercurial repository."""
system_hgrc_path: Path
backing_repo: hgrepo.HgRepository
def create_transient_dir(self) -> None:
super().create_transient_dir()
# Note that we put the system hgrc file in self.transient_dir rather than
# self.data_dir:
# This file is not saved with the snapshot, and is instead regenerated each time
# we unpack the snapshot. This reflects the fact that we always run with the
# current system hgrc rather than an old snapshot of the system configs.
self.system_hgrc_path = self.transient_dir / "system_hgrc"
self.system_hgrc_path.write_text(hgrepo.HgRepository.get_system_hgrc_contents())
def hg_repo(self, path: Path) -> hgrepo.HgRepository:
return hgrepo.HgRepository(str(path), system_hgrc=str(self.system_hgrc_path))
def gen_before_eden_running(self) -> None:
logging.info("Creating backing repository...")
# Create the repository
backing_repo_path = self.data_dir / "repo"
backing_repo_path.mkdir()
self.backing_repo = self.hg_repo(backing_repo_path)
self.backing_repo.init()
self.populate_backing_repo()
def gen_eden_running(self, eden: edenclient.EdenFS) -> None:
logging.info("Preparing checkout...")
eden.clone(self.backing_repo.path, str(self.checkout_path))
# pyre-fixme[16]: `HgSnapshot` has no attribute `checkout_repo`.
self.checkout_repo = self.hg_repo(self.checkout_path)
self.populate_checkout()
@abc.abstractmethod
def populate_backing_repo(self) -> None:
pass
@abc.abstractmethod
def populate_checkout(self) -> None:
pass
@property
def checkout_path(self) -> Path:
"""Return the path to the checkout root."""
return self.data_dir / "checkout"
def read_file(self, path: Union[Path, str]) -> bytes:
"""Helper function to read a file in the checkout.
This is primarily used to ensure that the file is loaded.
"""
file_path = self.checkout_path / path
with file_path.open("rb") as f:
data: bytes = f.read()
return data
def write_file(
self, path: Union[Path, str], contents: bytes, mode: int = 0o644
) -> None:
"""Helper function to write a file in the checkout."""
file_path = self.checkout_path / path
file_path.parent.mkdir(parents=True, exist_ok=True)
with file_path.open("wb") as f:
os.fchmod(f.fileno(), mode)
f.write(contents)
def symlink(self, path: Union[Path, str], contents: bytes) -> None:
"""Helper function to create or update a symlink in the checkout."""
file_path = self.checkout_path / path
try:
file_path.unlink()
except FileNotFoundError:
file_path.parent.mkdir(parents=True, exist_ok=True)
os.symlink(contents, bytes(file_path))
def chmod(self, path: Union[Path, str], mode: int) -> None:
file_path = self.checkout_path / path
os.chmod(file_path, mode)
def mkdir(self, path: Union[Path, str], mode: int = 0o755) -> None:
dir_path = self.checkout_path / path
dir_path.mkdir(mode=mode, parents=True, exist_ok=False)
# Explicitly call chmod() to ignore any umask settings
dir_path.chmod(mode)
def list_dir(self, path: Union[Path, str]) -> List[Path]:
"""List the contents of a directory in the checkout.
This can be used to ensure the directory has been loaded by Eden.
"""
dir_path = self.checkout_path / path
return list(dir_path.iterdir())
def make_socket(self, path: Union[Path, str], mode: int = 0o755) -> None:
socket_path = self.checkout_path / path
socket_path.parent.mkdir(parents=True, exist_ok=True)
with socket.socket(socket.AF_UNIX) as sock:
# Call fchmod() before we create the socket to ensure that its initial
# permissions are not looser than requested. The OS will still honor the
# umask when creating the socket.
os.fchmod(sock.fileno(), mode)
sock.bind(str(socket_path))
sock.listen(10)
# Call chmod() update the permissions ignoring the umask.
# Note that we unfortunately must use path.chmod() here rather than
# os.fchmod(): Linux appears to ignore fchmod() calls after the socket has
# already been bound.
socket_path.chmod(mode)
snapshot_types: Dict[str, Type[BaseSnapshot]] = {}
def snapshot_class(
name: str, description: str
) -> Callable[[Type[BaseSnapshot]], Type[BaseSnapshot]]:
"""A decorator for registering snapshot implementations."""
def wrapper(snapshot: Type[BaseSnapshot]) -> Type[BaseSnapshot]:
snapshot.NAME = name
snapshot.DESCRIPTION = description
snapshot_types[name] = snapshot
return snapshot
return wrapper
@contextlib.contextmanager
def generate(snapshot_type: Type[T]) -> Iterator[T]:
"""Generate a snapshot using the specified snapshot type.
The argument must be a subclass of BaseSnapshot.
This should be used in a `with` statement. This method generates the snapshot in a
temporary directory that will be cleaned up when exiting the `with` context.
"""
with create_tmp_dir() as tmpdir:
snapshot = snapshot_type(tmpdir)
snapshot.generate()
yield snapshot
class UnknownSnapshotTypeError(ValueError):
def __init__(self, type_name: str) -> None:
super().__init__(f"unknown snapshot type {type_name!r}")
self.type_name = type_name
def unpack_into(snapshot_path: Path, output_path: Path) -> BaseSnapshot:
"""Unpack a snapshot into the specified output directory.
Returns the appropriate BaseSnapshot subclass for this snapshot.
"""
# GNU tar is smart enough to automatically figure out the correct
# decompression method.
untar_cmd = ["tar", "-xf", str(snapshot_path.absolute())]
subprocess.check_call(untar_cmd, cwd=output_path)
data_dir = output_path / "data"
try:
with (data_dir / "info.json").open("r") as info_file:
info = json.load(info_file)
type_name = info["type"]
snapshot_type = snapshot_types.get(type_name)
if snapshot_type is None:
raise UnknownSnapshotTypeError(type_name)
# pyre-fixme[45]: Cannot instantiate abstract class `BaseSnapshot`.
snapshot = snapshot_type(output_path)
snapshot.resume()
return snapshot
except Exception:
cleanup_tmp_dir(data_dir)
raise
def _import_snapshot_modules() -> None:
import __manifest__
# Find and import all modules in our "types" sub-package.
# Each module will register its snapshot types when imported.
package_prefix = f"{__package__}.types."
for module in __manifest__.modules:
if module.startswith(package_prefix):
__import__(module)
def get_snapshots_root() -> Path:
"""
Return the path where snapshots are stored.
"""
root = os.environ.get("EDENFS_SNAPSHOTS", "eden/test-data")
return Path(root).resolve() / "snapshots"
# Automatically import all snapshot modules to register their snapshot classes
_import_snapshot_modules()
```
|
The Marqués government was the regional government of Asturias led by President Sergio Marqués. It was formed in July 1995 after the regional election, becoming the first time that the Asturian Socialist Federation did not take the helm of the Council of Government.
In 1998, after several differences with members of the People's Party of Asturias, Marqués left the party and created his own one: the Asturian Renewal Union and remained in the government until 1999, despite a motion of no confidence.
Investiture
Composition
References
Cabinets of Asturias
Cabinets established in 1995
|
```prolog
package doCommand;
#
# This plugin is licensed under the GNU GPL
# --------------------------------------------------
use strict;
use Plugins;
use Globals;
use Log qw(message warning error);
use Misc;
use Utils;
use Commands;
use Time::HiRes qw(time);
Plugins::register('doCommand', 'do a command on certain conditions', \&Unload);
my $hook = Plugins::addHook('AI_post', \&doCommand);
sub Unload {
Plugins::delHook('AI_post', $hook);
}
my $time;
sub doCommand {
my $prefix = "doCommand_";
for (my $i =0; (exists $config{$prefix.$i}); $i++) {
if ((main::checkSelfCondition($prefix.$i)) && main::timeOut($time, $config{$prefix.$i."_timeout"})) {
Commands::run($config{$prefix.$i});
$time = time;
}
}
}
return 1;
```
|
```javascript
/* eslint-disable no-mixed-operators */
export default function(items, props) {
const {
columnWidth,
itemHeight = 150,
columns,
gutterWidth,
gutterHeight
} = props;
const positions = items.map((itemProps, i) => {
const column = i % columns;
const row = Math.floor(i / columns);
const x = column * columnWidth + column * gutterWidth;
const y = row * itemHeight + row * gutterHeight;
return [x, y];
});
const gridWidth = columns * columnWidth + (columns - 1) * gutterWidth;
const gridHeight =
Math.ceil(items.length / columns) * (itemHeight + gutterHeight) -
gutterHeight;
return { positions, gridWidth, gridHeight };
}
```
|
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, height=device-height, initial-scale=1.0, maximum-scale=1.0" />
<link rel="stylesheet" href="path_to_url">
<link rel="stylesheet" href="../../css/froala_editor.css">
<link rel="stylesheet" href="../../css/froala_style.css">
<link rel="stylesheet" href="../../css/plugins/code_view.css">
<link rel="stylesheet" href="../../css/plugins/colors.css">
<link rel="stylesheet" href="../../css/plugins/emoticons.css">
<link rel="stylesheet" href="../../css/plugins/image_manager.css">
<link rel="stylesheet" href="../../css/plugins/image.css">
<link rel="stylesheet" href="../../css/plugins/line_breaker.css">
<link rel="stylesheet" href="../../css/plugins/table.css">
<link rel="stylesheet" href="../../css/plugins/char_counter.css">
<link rel="stylesheet" href="../../css/plugins/video.css">
<link rel="stylesheet" href="../../css/plugins/fullscreen.css">
<link rel="stylesheet" href="../../css/plugins/file.css">
<link rel="stylesheet" href="path_to_url">
<style>
body {
text-align: center;
}
div#editor {
width: 81%;
margin: auto;
text-align: left;
}
</style>
</head>
<body>
<div id="editor">
<div id='edit' style="margin-top: 30px;">
<h1>Shortcuts</h1>
<p>Change what shortcuts should be available in the WYSIWYG HTML editor using the <a
href="path_to_url#shortcutsEnabled" target="_blank"
title="shortcutsEnabled option">shortcutsEnabled</a> option.</p>
<p>Shortcuts are also be visible in the button tooltips. Disable this feature using the <a
href="path_to_url#shortcutsHint" target="_blank"
title="shortcutsHint option">shortcutsHint</a> option.</p>
</div>
</div>
<script type="text/javascript"
src="path_to_url"></script>
<script type="text/javascript"
src="path_to_url"></script>
<script type="text/javascript" src="../../js/froala_editor.min.js"></script>
<script type="text/javascript" src="../../js/plugins/align.min.js"></script>
<script type="text/javascript" src="../../js/plugins/code_beautifier.min.js"></script>
<script type="text/javascript" src="../../js/plugins/code_view.min.js"></script>
<script type="text/javascript" src="../../js/plugins/colors.min.js"></script>
<script type="text/javascript" src="../../js/plugins/draggable.min.js"></script>
<script type="text/javascript" src="../../js/plugins/emoticons.min.js"></script>
<script type="text/javascript" src="../../js/plugins/font_size.min.js"></script>
<script type="text/javascript" src="../../js/plugins/font_family.min.js"></script>
<script type="text/javascript" src="../../js/plugins/image.min.js"></script>
<script type="text/javascript" src="../../js/plugins/file.min.js"></script>
<script type="text/javascript" src="../../js/plugins/image_manager.min.js"></script>
<script type="text/javascript" src="../../js/plugins/line_breaker.min.js"></script>
<script type="text/javascript" src="../../js/plugins/link.min.js"></script>
<script type="text/javascript" src="../../js/plugins/lists.min.js"></script>
<script type="text/javascript" src="../../js/plugins/paragraph_format.min.js"></script>
<script type="text/javascript" src="../../js/plugins/paragraph_style.min.js"></script>
<script type="text/javascript" src="../../js/plugins/video.min.js"></script>
<script type="text/javascript" src="../../js/plugins/table.min.js"></script>
<script type="text/javascript" src="../../js/plugins/url.min.js"></script>
<script type="text/javascript" src="../../js/plugins/entities.min.js"></script>
<script type="text/javascript" src="../../js/plugins/char_counter.min.js"></script>
<script type="text/javascript" src="../../js/plugins/inline_style.min.js"></script>
<script type="text/javascript" src="../../js/plugins/save.min.js"></script>
<script type="text/javascript" src="../../js/plugins/fullscreen.min.js"></script>
<script>
(function () {
new FroalaEditor("#edit", {
// Set the list of available shortcuts.
shortcutsEnabled: ['bold', 'italic'],
// Disable shortcut hints.
shortcutsHint: false
})
})()
</script>
</body>
</html>
```
|
Chiara Consonni (born 24 June 1999) is an Italian racing cyclist, who currently rides for UCI Women's World Team . She rode for in the women's team time trial event at the 2018 UCI Road World Championships.
Her older brother Simone Consonni is also a professional cyclist.
Major results
Road
2017
3rd Diamond Tour
7th Gent-Wevelgem Junior
2018
1st Young rider classification, Ladies Tour of Norway
3rd Diamond Tour
7th Omloop van Borsele
8th Brabantse Pijl
2019
1st Stage 5 Boels Ladies Tour
3rd Gran Premio Bruno Beghelli
5th Tour of Guangxi Women's WorldTour
2020
2nd Grand Prix d'Isbergues
3rd GP de Plouay
2021
1st Ronde de Mouscron
1st Vuelta a la Comunitat Valenciana
1st Grand Prix de Plumelec-Morbihan
2nd Diamond Tour
3rd La Classique Morbihan
9th Ronde van Drenthe
2022
1st Dwars door Vlaanderen
1st Dwars door de Westhoek
1st Diamond Tour
1st Grand Prix d'Isbergues
1st Stage 9 Giro Donne
2nd Le Samyn
2nd GP Oetingen
2nd Scheldeprijs
2nd Gran Premio della Liberazione
4th Nokere Koerse
4th Road race, National Championships
5th Overall RideLondon Classique
7th Ronde van Drenthe
7th Classic Brugge–De Panne
7th Drentse Acht van Westerveld
7th Ronde de Mouscron
2023
1st Trofee Maarten Wynants
1st Stage 9 Giro Donne
2nd Dwars door Vlaanderen
3rd Scheldeprijs
9th Paris–Roubaix
9th Classic Brugge–De Panne
Track
2016
1st Team pursuit, UCI World Junior Championships
1st Team pursuit, UEC European Junior Championships
2nd Team sprint, National Junior Championships
2017
UCI World Junior Championships
1st Team pursuit
1st Madison (with Letizia Paternoster)
3rd Points race
UEC European Junior Championships
1st Team pursuit
1st Madison (with Letizia Paternoster)
2018
National Championships
2nd Madison (with Marta Cavalli)
3rd Omnium
2019
UCI World Cup
3rd Team pursuit, Glasgow
3rd Madison, Hong Kong (with Vittoria Guazzini)
2020
UEC European Under-23 Championships
1st Team pursuit
1st Madison (with Martina Fidanza)
2022
1st Team pursuit, UCI World Championships
References
External links
1999 births
Living people
Italian female cyclists
Italian track cyclists
People from Ponte San Pietro
Cyclists from the Province of Bergamo
UCI Track Cycling World Champions (women)
21st-century Italian women
|
```glsl
//
//
// 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.
#version 450
#extension GL_ARB_separate_shader_objects : enable
#extension GL_ARB_shading_language_420pack : enable
#extension GL_GOOGLE_include_directive : enable
#define BLUR_WIDTH 15
#define HALF_BLUR_WIDTH 7
#define BLUR_THREADS 128
const float blurWeights[] = {0.0, 0.0, 0.000003, 0.000229, 0.005977,
0.060598, 0.24173, 0.382925, 0.24173, 0.060598,
0.005977, 0.000229, 0.000003, 0.0, 0.0};
layout(binding = 0) uniform PerInstance { ivec4 mipLevel; }
uboPerInstance;
layout(binding = 1, rgba16f) uniform image2D outTex;
layout(binding = 2) uniform sampler2D inTex;
shared vec4 temp[BLUR_THREADS];
layout(local_size_x = BLUR_THREADS, local_size_y = 1) in;
void main()
{
ivec2 coord =
ivec2(gl_LocalInvocationIndex - HALF_BLUR_WIDTH +
(BLUR_THREADS - HALF_BLUR_WIDTH * 2) * gl_WorkGroupID.x,
gl_WorkGroupID.y)
.yx;
temp[gl_LocalInvocationIndex] =
texelFetch(inTex, coord, uboPerInstance.mipLevel.x);
barrier();
if (gl_LocalInvocationIndex >= HALF_BLUR_WIDTH &&
gl_LocalInvocationIndex < (BLUR_THREADS - HALF_BLUR_WIDTH))
{
vec4 out0 = vec4(0.0);
for (int i = -HALF_BLUR_WIDTH; i <= HALF_BLUR_WIDTH; ++i)
out0 +=
temp[gl_LocalInvocationIndex + i] * blurWeights[i + HALF_BLUR_WIDTH];
imageStore(outTex, ivec2(gl_LocalInvocationIndex - HALF_BLUR_WIDTH +
(BLUR_THREADS - HALF_BLUR_WIDTH * 2) *
gl_WorkGroupID.x,
gl_GlobalInvocationID.y)
.yx,
out0);
}
}
```
|
Ratyauli () is a traditional Nepalese event performed in the bride or groom's house in the wedding evening by female relatives and guests. Male are strictly prohibited in the event. In the event, women play games, sing traditional songs and dance which has some explicit content. In modern times, Ratyauli events are organized in public places as well.
Proceedings
The traditional Ratyauli is organized in three parts based on the sequence of marriage. In the first part, songs are sung describing the events before the groom comes to take the bride in her house. In the middle part, songs describe the event from wedding to the time when groom takes the bride to his home. It also describes the relationship between in-laws and new bride. In this section, the explicit part is sung. In the end part, songs describe the best wishes to the new couple by praying to gods and goddesses.
See also
Dohori, traditional music of Nepal
References
Nepalese culture
Dance in Nepal
Marriage in Nepal
Nepalese folk music
Culture of Bagmati
Culture of Gandaki
Culture of Lumbini
Nepalese musical genres
|
```xml
import { isRequestEqual, isDupe } from '../../src/JestProcessManagement/helper';
jest.unmock('../../src/JestProcessManagement/helper');
describe('isRequestEqual', () => {
it.each`
r1 | r2 | isEqual
${{ type: 'all-tests' }} | ${{ type: 'all-tests' }} | ${true}
${{ type: 'all-tests' }} | ${{ type: 'watch-tests' }} | ${false}
${{ type: 'watch-tests' }} | ${{ type: 'watch-all-tests' }} | ${false}
${{ type: 'by-file', testFileName: 'abc' }} | ${{ type: 'by-file', testFileName: 'abc' }} | ${true}
${{ type: 'by-file', testFileName: 'abc' }} | ${{ type: 'by-file', testFileName: 'abc', extra: 'whatever' }} | ${true}
${{ type: 'by-file', testFileName: 'abc' }} | ${{ type: 'by-file', testFileName: 'def' }} | ${false}
${{ type: 'by-file', testFileName: undefined }} | ${{ type: 'by-file', testFileName: null }} | ${false}
${{ type: 'by-file', testFileName: 'abc' }} | ${{ type: 'by-file' }} | ${false}
${{ type: 'by-file-pattern', testFileNamePattern: 'abc' }} | ${{ type: 'by-file-pattern', testFileNamePattern: 'abc' }} | ${true}
${{ type: 'by-file-pattern', testFileNamePattern: 'abc' }} | ${{ type: 'by-file-pattern', testFileNamePattern: 'Abc' }} | ${false}
${{ type: 'by-file-test', testFileName: 'abc', testNamePattern: '123' }} | ${{ type: 'by-file-test', testFileName: 'abc', testNamePattern: '123' }} | ${true}
${{ type: 'by-file-test', testFileName: 'abc' }} | ${{ type: 'by-file-test', testFileName: 'abc', testNamePattern: '123' }} | ${false}
${{ type: 'by-file-test', testFileName: 'abc' }} | ${{ type: 'by-file-test', testFileName: 'abc' }} | ${true}
${{ type: 'by-file-test-pattern', testFileNamePattern: 'abc', testNamePattern: '123' }} | ${{ type: 'by-file-test-pattern', testFileNamePattern: 'abc', testNamePattern: '123' }} | ${true}
${{ type: 'by-file-test-pattern', testFileNamePattern: 'abc', testNamePattern: '123' }} | ${{ type: 'by-file-test', testFileName: 'abc', testNamePattern: '123' }} | ${false}
${{ type: 'not-test', args: ['abc', 'xyz'] }} | ${{ type: 'not-test', args: ['abc', 'xyz'] }} | ${true}
${{ type: 'not-test', args: ['abc', 'xyz'] }} | ${{ type: 'not-test', args: ['abc'] }} | ${false}
${{ type: 'not-test', args: [] }} | ${{ type: 'not-test', args: ['abc'] }} | ${false}
`('$r1 ?== $r2 ? $isEqual', ({ r1, r2, isEqual }) => {
expect(isRequestEqual(r1, r2)).toEqual(isEqual);
});
});
describe('isDup', () => {
it('not dup if no check is specified', () => {
const task: any = {
data: { request: { type: 'watch-tests' } },
status: 'pending',
};
const request1: any = { type: 'watch-tests', schedule: {} };
expect(isDupe(task, request1)).toBeFalsy();
});
it('can check by request type', () => {
const task: any = {
data: { request: { type: 'watch-tests' } },
status: 'pending',
};
const request1: any = { type: 'watch-tests', schedule: { dedupe: {} } };
const request2: any = { type: 'all-tests', schedule: { dedupe: {} } };
expect(isDupe(task, request1)).toBeTruthy();
expect(isDupe(task, request2)).toBeFalsy();
});
it.each`
type | status | expected
${'watch-tests'} | ${['running']} | ${false}
${'watch-tests'} | ${['pending']} | ${true}
${'watch-tests'} | ${['running', 'pending']} | ${true}
${'watch-all-tests'} | ${['pending']} | ${false}
`('can check by request $type and $status, isDup = $expected', ({ type, status, expected }) => {
const task: any = {
data: { request: { type: 'watch-tests' } },
status: 'pending',
};
const request: any = {
type,
schedule: { dedupe: { filterByStatus: status } },
};
expect(isDupe(task, request)).toEqual(expected);
});
it.each`
type | status | testFileName | expected
${'by-file'} | ${['running']} | ${'abc'} | ${false}
${'by-file'} | ${['pending']} | ${'abc'} | ${true}
${'by-file'} | ${['pending']} | ${'def'} | ${false}
${'by-file'} | ${['pending']} | ${undefined} | ${false}
${'by-file'} | ${undefined} | ${'abc'} | ${true}
${'watch-all-tests'} | ${['pending']} | ${'abc'} | ${false}
`(
'can check by $type, $status, filterByContent=$filterByContent, isDup = $expected',
({ type, status, testFileName, expected }) => {
const task: any = {
data: { request: { type: 'by-file', testFileName: 'abc' } },
status: 'pending',
};
const request: any = {
type,
testFileName,
schedule: { dedupe: { filterByStatus: status, filterByContent: true } },
};
expect(isDupe(task, request)).toEqual(expected);
}
);
});
```
|
```objective-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.
==============================================================================*/
#ifndef TENSORFLOW_COMMON_RUNTIME_EXECUTOR_H_
#define TENSORFLOW_COMMON_RUNTIME_EXECUTOR_H_
#include "tensorflow/core/common_runtime/device.h"
#include "tensorflow/core/framework/rendezvous.h"
#include "tensorflow/core/framework/session_state.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/graph/graph.h"
#include "tensorflow/core/lib/core/notification.h"
#include "tensorflow/core/lib/core/status.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/macros.h"
namespace tensorflow {
class StepStatsCollector;
// Executor runs a graph computation.
// Example:
// Graph* graph = ...;
// ... construct graph ...
// Executor* executor;
// TF_CHECK_OK(NewSimpleExecutor(my_device, graph, &executor));
// Rendezvous* rendezvous = NewNaiveRendezvous();
// TF_CHECK_OK(rendezvous->Send("input", some_input_tensor));
// TF_CHECK_OK(executor->Run({ExecutorOpts, rendezvous, nullptr}));
// TF_CHECK_OK(rendezvous->Recv("output", &output_tensor));
// ... ...
//
// Multiple threads can call Executor::Run concurrently.
class Executor {
public:
virtual ~Executor() {}
// RunAsync() executes the graph computation. "done" is run when the
// graph computation completes. If any error happens during the
// computation, "done" is run and the error is passed to "done".
//
// RunAsync() is given a few arguments in Args. The caller must
// ensure objects passed in Args (rendezvous, stats_collector, etc.)
// are alive at least until done is invoked. All pointers to the
// argument objects can be nullptr.
//
// "step_id" is a process-wide unique identifier for the step being
// run. Executors on different devices may receive the same step_id
// in the case that a step runs Ops on more than one device. The
// step_id is used for tracking resource usage of a given step.
//
// RunAsync() uses the given "rendezvous", if not null, as the
// mechanism to communicate inputs and outputs of the underlying
// graph computation.
//
// RunAsync() calls "stats_collector", if not null, to keep track of
// stats. This allows us to collect statistics and traces on demand.
//
// RunAsync() is provided a "call_frame", if the executor is used
// for executing a function, is used to pass arguments and return
// values between the caller and the callee.
//
// RunAsync() uses "cancellation_manager", if not nullptr, to
// register callbacks that should be called if the graph computation
// is cancelled. Note that the callbacks merely unblock any
// long-running computation, and a cancelled step will terminate by
// returning/calling the DoneCallback as usual.
//
// RunAsync() dispatches closures to "runner". Typically, "runner"
// is backed up by a bounded threadpool.
struct Args {
int64 step_id = 0;
Rendezvous* rendezvous = nullptr;
StepStatsCollector* stats_collector = nullptr;
FunctionCallFrame* call_frame = nullptr;
CancellationManager* cancellation_manager = nullptr;
SessionState* session_state = nullptr;
TensorStore* tensor_store = nullptr;
ScopedStepContainer* step_container = nullptr;
// If true, calls Sync() on the device.
bool sync_on_finish = false;
typedef std::function<void()> Closure;
typedef std::function<void(Closure)> Runner;
Runner runner = nullptr;
// A callback that is invoked each time a node has finished executing.
typedef std::function<Status(const string& node_name, const int output_slot,
const Tensor* tensor, const bool is_ref,
OpKernelContext* ctx)>
NodeOutputsCallback;
NodeOutputsCallback node_outputs_cb = nullptr;
};
typedef std::function<void(const Status&)> DoneCallback;
virtual void RunAsync(const Args& args, DoneCallback done) = 0;
// Synchronous wrapper for RunAsync().
Status Run(const Args& args) {
Status ret;
Notification n;
RunAsync(args, [&ret, &n](const Status& s) {
ret = s;
n.Notify();
});
n.WaitForNotification();
return ret;
}
};
// Creates an Executor that computes the given "graph".
//
// If successful, returns the constructed executor in "*executor". The
// caller keeps the ownership of "device". The returned executor takes
// the ownership of "graph". Otherwise, returns an error status.
//
// "params" provides a set of context for the executor. We expect that
// different context would provide different implementations.
struct LocalExecutorParams {
Device* device;
// The library runtime support.
FunctionLibraryRuntime* function_library = nullptr;
// create_kernel returns an instance of op kernel based on NodeDef.
// delete_kernel is called for every kernel used by the executor
// when the executor is deleted.
std::function<Status(const NodeDef&, OpKernel**)> create_kernel;
std::function<void(OpKernel*)> delete_kernel;
Executor::Args::NodeOutputsCallback node_outputs_cb;
};
::tensorflow::Status NewLocalExecutor(const LocalExecutorParams& params,
const Graph* graph, Executor** executor);
// A class to help run multiple executors in parallel and wait until
// all of them are complete.
//
// ExecutorBarrier deletes itself after the function returned by Get()
// is called.
class ExecutorBarrier {
public:
typedef std::function<void(const Status&)> StatusCallback;
// Create an ExecutorBarrier for 'num' different executors.
//
// 'r' is the shared Rendezvous object that is used to communicate
// state. If any of the executors experiences an error, the
// rendezvous object will be aborted exactly once.
//
// 'done' is called after the last executor completes, and
// ExecutorBarrier is deleted.
ExecutorBarrier(int num, Rendezvous* r, StatusCallback done)
: rendez_(r), done_cb_(done), pending_(num) {}
~ExecutorBarrier() {}
// Returns a closure that Executors must call when they are done
// computing, passing the status of their execution as an argument.
StatusCallback Get() {
return std::bind(&ExecutorBarrier::WhenDone, this, std::placeholders::_1);
}
private:
Rendezvous* rendez_ = nullptr;
StatusCallback done_cb_ = nullptr;
mutable mutex mu_;
int pending_ GUARDED_BY(mu_) = 0;
Status status_ GUARDED_BY(mu_);
void WhenDone(const Status& s) {
bool error = false;
Rendezvous* error_rendez = nullptr;
StatusCallback done = nullptr;
Status status;
{
mutex_lock l(mu_);
// If we are the first error encountered, mark the status
// appropriately and later trigger an abort of the Rendezvous
// object by this thread only.
if (status_.ok() && !s.ok()) {
error = true;
error_rendez = rendez_;
error_rendez->Ref();
status_ = s;
}
// If this is the last call to WhenDone, call the final callback
// below.
if (--pending_ == 0) {
CHECK(done_cb_ != nullptr);
done = done_cb_;
done_cb_ = nullptr;
}
status = status_;
}
if (error) {
error_rendez->StartAbort(status);
error_rendez->Unref();
}
if (done != nullptr) {
delete this;
done(status);
}
}
TF_DISALLOW_COPY_AND_ASSIGN(ExecutorBarrier);
};
// A few helpers to facilitate create/delete kernels.
// Creates a kernel based on "ndef" on device "device". The kernel can
// access the functions in the "flib". The caller takes ownership of
// returned "*kernel".
Status CreateNonCachedKernel(Device* device, FunctionLibraryRuntime* flib,
const NodeDef& ndef, int graph_def_version,
OpKernel** kernel);
// Deletes "kernel" returned by CreateKernel.
void DeleteNonCachedKernel(OpKernel* kernel);
} // end namespace tensorflow
#endif // TENSORFLOW_COMMON_RUNTIME_EXECUTOR_H_
```
|
The 2004 SCCA ProRally Season was the 32nd and last season of the SCCA ProRally and won by Canadian Patrick Richard from British Columbia and his co-driver and sister Nathalie. Nine rounds were held from January 2004 to October 2004. It was the final season of SCCA ProRally as the series became known as Rally America from 2005.
Teams and Drivers
Calendar
Sno*Drift Rally won by Pat Richard
Oregon Trail ProRally won by Pat Richard
Rim of the World ProRally won by Pat Richard
Susquehannock Trail ProRally won by Shane Mitchell
Pikes Peak ProRally won by Leon Styles
Maine Forest Rally won by Paul Choiniere
Ojibwe Forests Rally won by Lauchlin O'Sullivan
Colorado Cog Rally won by Leon Styles
Lake Superior ProRally won by Seamus Burke
References
External links
2004 Results at rallyracingnews.com
2004 in motorsport
2004 in rallying
|
Bokowe is a village in the administrative district of Gmina Narewka, within Hajnówka County, Podlaskie Voivodeship, in north-eastern Poland, close to the border with Belarus. It lies approximately north-west of Narewka, north-east of Hajnówka, and south-east of the regional capital Białystok.
It is in one of five Polish/Belarusian bilingual Gmina in Podlaskie Voivodeship regulated by the Act of 6 January 2005 on National and Ethnic Minorities and on the Regional Languages, which permits certain gminas with significant linguistic minorities to introduce a second, auxiliary language to be used in official contexts alongside Polish.
References
Bokowe
|
```c++
#define TORCH_ASSERT_ONLY_METHOD_OPERATORS
#include <ATen/native/GridSampler.h>
#include <ATen/native/GridSamplerUtils.h>
#include <ATen/core/Tensor.h>
#include <ATen/Dispatch.h>
#include <ATen/Parallel.h>
#include <ATen/cpu/vec/vec.h>
#include <ATen/native/UpSample.h>
#include <ATen/native/cpu/GridSamplerKernel.h>
#include <c10/util/Exception.h>
#include <c10/util/irange.h>
#ifndef AT_PER_OPERATOR_HEADERS
#include <ATen/Functions.h>
#include <ATen/NativeFunctions.h>
#else
#include <ATen/ops/_empty_affine_quantized.h>
#include <ATen/ops/_grid_sampler_2d_cpu_fallback_backward_native.h>
#include <ATen/ops/_grid_sampler_2d_cpu_fallback_native.h>
#include <ATen/ops/cudnn_grid_sampler.h>
#include <ATen/ops/empty.h>
#include <ATen/ops/empty_like.h>
#include <ATen/ops/grid_sampler_2d.h>
#include <ATen/ops/grid_sampler_2d_backward_native.h>
#include <ATen/ops/grid_sampler_2d_native.h>
#include <ATen/ops/grid_sampler_3d.h>
#include <ATen/ops/grid_sampler_3d_backward_native.h>
#include <ATen/ops/grid_sampler_3d_native.h>
#include <ATen/ops/grid_sampler_native.h>
#include <ATen/ops/zeros_like.h>
#endif
namespace at::native {
using at::native::detail::GridSamplerInterpolation;
using at::native::detail::GridSamplerPadding;
namespace {
template<typename scalar_t>
Tensor grid_sampler_3d_cpu_impl(const Tensor& input, const Tensor& grid,
GridSamplerInterpolation interpolation_mode,
GridSamplerPadding padding_mode,
bool align_corners) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_3d(
input, grid, static_cast<int64_t>(interpolation_mode));
int64_t N = input.size(0);
int64_t C = input.size(1);
int64_t inp_D = input.size(2);
int64_t inp_H = input.size(3);
int64_t inp_W = input.size(4);
int64_t out_D = grid.size(1);
int64_t out_H = grid.size(2);
int64_t out_W = grid.size(3);
auto output = at::empty({N, C, out_D, out_H, out_W}, input.options());
if (output.numel() == 0) {
return output;
}
int64_t inp_sN = input.stride(0);
int64_t inp_sC = input.stride(1);
int64_t inp_sD = input.stride(2);
int64_t inp_sH = input.stride(3);
int64_t inp_sW = input.stride(4);
int64_t grid_sN = grid.stride(0);
int64_t grid_sD = grid.stride(1);
int64_t grid_sH = grid.stride(2);
int64_t grid_sW = grid.stride(3);
int64_t grid_sCoor = grid.stride(4);
int64_t out_sN = output.stride(0);
int64_t out_sC = output.stride(1);
int64_t out_sD = output.stride(2);
int64_t out_sH = output.stride(3);
int64_t out_sW = output.stride(4);
const scalar_t *inp_ptr = input.const_data_ptr<scalar_t>();
scalar_t *out_ptr = output.data_ptr<scalar_t>();
const scalar_t *grid_ptr = grid.const_data_ptr<scalar_t>();
// loop over each output pixel
at::parallel_for(0, N, 0, [&](int64_t start, int64_t end) {
for (const auto n : c10::irange(start, end)) {
const scalar_t *grid_ptr_N = grid_ptr + n * grid_sN;
const scalar_t *inp_ptr_N = inp_ptr + n * inp_sN;
for (const auto d : c10::irange(out_D)) {
for (const auto h : c10::irange(out_H)) {
for (const auto w : c10::irange(out_W)) {
// get the corresponding input x, y, z co-ordinates from grid
const scalar_t *grid_ptr_NDHW = grid_ptr_N + d * grid_sD + h * grid_sH + w * grid_sW;
scalar_t ix = *grid_ptr_NDHW;
scalar_t iy = grid_ptr_NDHW[grid_sCoor];
scalar_t iz = grid_ptr_NDHW[2 * grid_sCoor];
ix = grid_sampler_compute_source_index(ix, inp_W, padding_mode, align_corners);
iy = grid_sampler_compute_source_index(iy, inp_H, padding_mode, align_corners);
iz = grid_sampler_compute_source_index(iz, inp_D, padding_mode, align_corners);
if (interpolation_mode == GridSamplerInterpolation::Bilinear) {
// get corner pixel values from (x, y, z)
// for 4d, we used north-east-south-west
// for 5d, we add top-bottom
int64_t ix_tnw = static_cast<int64_t>(std::floor(ix));
int64_t iy_tnw = static_cast<int64_t>(std::floor(iy));
int64_t iz_tnw = static_cast<int64_t>(std::floor(iz));
int64_t ix_tne = ix_tnw + 1;
int64_t iy_tne = iy_tnw;
int64_t iz_tne = iz_tnw;
int64_t ix_tsw = ix_tnw;
int64_t iy_tsw = iy_tnw + 1;
int64_t iz_tsw = iz_tnw;
int64_t ix_tse = ix_tnw + 1;
int64_t iy_tse = iy_tnw + 1;
int64_t iz_tse = iz_tnw;
int64_t ix_bnw = ix_tnw;
int64_t iy_bnw = iy_tnw;
int64_t iz_bnw = iz_tnw + 1;
int64_t ix_bne = ix_tnw + 1;
int64_t iy_bne = iy_tnw;
int64_t iz_bne = iz_tnw + 1;
int64_t ix_bsw = ix_tnw;
int64_t iy_bsw = iy_tnw + 1;
int64_t iz_bsw = iz_tnw + 1;
int64_t ix_bse = ix_tnw + 1;
int64_t iy_bse = iy_tnw + 1;
int64_t iz_bse = iz_tnw + 1;
// get surfaces to each neighbor:
scalar_t tnw = (ix_bse - ix) * (iy_bse - iy) * (iz_bse - iz);
scalar_t tne = (ix - ix_bsw) * (iy_bsw - iy) * (iz_bsw - iz);
scalar_t tsw = (ix_bne - ix) * (iy - iy_bne) * (iz_bne - iz);
scalar_t tse = (ix - ix_bnw) * (iy - iy_bnw) * (iz_bnw - iz);
scalar_t bnw = (ix_tse - ix) * (iy_tse - iy) * (iz - iz_tse);
scalar_t bne = (ix - ix_tsw) * (iy_tsw - iy) * (iz - iz_tsw);
scalar_t bsw = (ix_tne - ix) * (iy - iy_tne) * (iz - iz_tne);
scalar_t bse = (ix - ix_tnw) * (iy - iy_tnw) * (iz - iz_tnw);
// calculate bilinear weighted pixel value and set output pixel
scalar_t *out_ptr_NCDHW = out_ptr + n * out_sN + d * out_sD + h * out_sH + w * out_sW;
const scalar_t *inp_ptr_NC = inp_ptr_N;
for (int64_t c = 0; c < C; ++c, out_ptr_NCDHW += out_sC, inp_ptr_NC += inp_sC) {
// (c, iz_tnw, iy_tnw, ix_tnw) * tnw + (c, iz_tne, iy_tne, ix_tne) * tne
// + (c, iz_tsw, iy_tsw, ix_tsw) * tsw + (c, iz_tse, iy_tse, ix_tse) * tse
// + (c, iz_bnw, iy_bnw, ix_bnw) * bnw + (c, iz_bne, iy_bne, ix_bne) * bne
// + (c, iz_bsw, iy_bsw, ix_bsw) * bsw + (c, iz_bse, iy_bse, ix_bse) * bse
*out_ptr_NCDHW = static_cast<scalar_t>(0);
if (within_bounds_3d(iz_tnw, iy_tnw, ix_tnw, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_tnw * inp_sD + iy_tnw * inp_sH + ix_tnw * inp_sW] * tnw;
}
if (within_bounds_3d(iz_tne, iy_tne, ix_tne, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_tne * inp_sD + iy_tne * inp_sH + ix_tne * inp_sW] * tne;
}
if (within_bounds_3d(iz_tsw, iy_tsw, ix_tsw, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_tsw * inp_sD + iy_tsw * inp_sH + ix_tsw * inp_sW] * tsw;
}
if (within_bounds_3d(iz_tse, iy_tse, ix_tse, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_tse * inp_sD + iy_tse * inp_sH + ix_tse * inp_sW] * tse;
}
if (within_bounds_3d(iz_bnw, iy_bnw, ix_bnw, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_bnw * inp_sD + iy_bnw * inp_sH + ix_bnw * inp_sW] * bnw;
}
if (within_bounds_3d(iz_bne, iy_bne, ix_bne, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_bne * inp_sD + iy_bne * inp_sH + ix_bne * inp_sW] * bne;
}
if (within_bounds_3d(iz_bsw, iy_bsw, ix_bsw, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_bsw * inp_sD + iy_bsw * inp_sH + ix_bsw * inp_sW] * bsw;
}
if (within_bounds_3d(iz_bse, iy_bse, ix_bse, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW += inp_ptr_NC[iz_bse * inp_sD + iy_bse * inp_sH + ix_bse * inp_sW] * bse;
}
}
} else if (interpolation_mode == GridSamplerInterpolation::Nearest) {
int64_t ix_nearest = static_cast<int64_t>(std::nearbyint(ix));
int64_t iy_nearest = static_cast<int64_t>(std::nearbyint(iy));
int64_t iz_nearest = static_cast<int64_t>(std::nearbyint(iz));
// assign nearest neighbour pixel value to output pixel
scalar_t *out_ptr_NCDHW = out_ptr + n * out_sN + d * out_sD + h * out_sH + w * out_sW;
const scalar_t *inp_ptr_NC = inp_ptr_N;
for (int64_t c = 0; c < C; ++c, out_ptr_NCDHW += out_sC, inp_ptr_NC += inp_sC) {
if (within_bounds_3d(iz_nearest, iy_nearest, ix_nearest, inp_D, inp_H, inp_W)) {
*out_ptr_NCDHW = inp_ptr_NC[iz_nearest * inp_sD + iy_nearest * inp_sH + ix_nearest * inp_sW];
} else {
*out_ptr_NCDHW = static_cast<scalar_t>(0);
}
}
}
}
}
}
}
});
return output;
}
template<typename scalar_t>
std::tuple<Tensor, Tensor>
grid_sampler_3d_backward_cpu_impl(const Tensor& grad_output,
const Tensor& input, const Tensor& grid,
GridSamplerInterpolation interpolation_mode,
GridSamplerPadding padding_mode,
bool align_corners, std::array<bool,2> output_mask) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_3d(
input, grid, static_cast<int64_t>(interpolation_mode));
auto input_requires_grad = output_mask[0];
Tensor grad_input = ([&]() {
if (input_requires_grad) {
return at::zeros_like(input, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
} else {
return Tensor();
}
})();
auto grad_grid = at::empty_like(grid, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
if (grid.numel() == 0 || input.numel() == 0) {
grad_grid.zero_();
return std::make_tuple(grad_input, grad_grid);
}
// If interpolation mode is Nearest, then grad_grid is not filled in the
// loop below.
if (interpolation_mode == GridSamplerInterpolation::Nearest) {
grad_grid.zero_();
}
int64_t N = input.size(0);
int64_t C = input.size(1);
int64_t inp_D = input.size(2);
int64_t inp_H = input.size(3);
int64_t inp_W = input.size(4);
int64_t out_D = grid.size(1);
int64_t out_H = grid.size(2);
int64_t out_W = grid.size(3);
int64_t inp_sN = input.stride(0);
int64_t inp_sC = input.stride(1);
int64_t inp_sD = input.stride(2);
int64_t inp_sH = input.stride(3);
int64_t inp_sW = input.stride(4);
int64_t grid_sN = grid.stride(0);
int64_t grid_sD = grid.stride(1);
int64_t grid_sH = grid.stride(2);
int64_t grid_sW = grid.stride(3);
int64_t grid_sCoor = grid.stride(4);
int64_t gOut_sN = grad_output.stride(0);
int64_t gOut_sC = grad_output.stride(1);
int64_t gOut_sD = grad_output.stride(2);
int64_t gOut_sH = grad_output.stride(3);
int64_t gOut_sW = grad_output.stride(4);
int64_t gInp_sN = 0;
int64_t gInp_sC = 0;
int64_t gInp_sD = 0;
int64_t gInp_sH = 0;
int64_t gInp_sW = 0;
if (input_requires_grad) {
gInp_sN = grad_input.stride(0);
gInp_sC = grad_input.stride(1);
gInp_sD = grad_input.stride(2);
gInp_sH = grad_input.stride(3);
gInp_sW = grad_input.stride(4);
}
int64_t gGrid_sN = grad_grid.stride(0);
int64_t gGrid_sW = grad_grid.stride(3);
const scalar_t *inp_ptr = input.const_data_ptr<scalar_t>();
const scalar_t *grid_ptr = grid.const_data_ptr<scalar_t>();
const scalar_t *gOut_ptr = grad_output.const_data_ptr<scalar_t>();
scalar_t *gInp_ptr = nullptr;
if (input_requires_grad) {
gInp_ptr = grad_input.mutable_data_ptr<scalar_t>();
}
scalar_t *gGrid_ptr = grad_grid.data_ptr<scalar_t>();
// loop over each output pixel
at::parallel_for(0, N, 0, [&](int64_t start, int64_t end) {
for (const auto n : c10::irange(start, end)) {
const scalar_t *grid_ptr_N = grid_ptr + n * grid_sN;
const scalar_t *inp_ptr_N = inp_ptr + n * inp_sN;
scalar_t *gGrid_ptr_NDHW = gGrid_ptr + n * gGrid_sN;
for (const auto d : c10::irange(out_D)) {
for (const auto h : c10::irange(out_H)) {
for (int64_t w = 0; w < out_W; ++w, gGrid_ptr_NDHW += gGrid_sW /* grad_grid is contiguous */ ) {
// get the corresponding input x, y, z co-ordinates from grid
const scalar_t *grid_ptr_NDHW = grid_ptr_N + d * grid_sD + h * grid_sH + w * grid_sW;
scalar_t ix = *grid_ptr_NDHW;
scalar_t iy = grid_ptr_NDHW[grid_sCoor];
scalar_t iz = grid_ptr_NDHW[2 * grid_sCoor];
// multipliers for gradients on ix, iy, and iz
scalar_t gix_mult, giy_mult, giz_mult;
ix = grid_sampler_compute_source_index_set_grad(ix, inp_W, padding_mode, align_corners, &gix_mult);
iy = grid_sampler_compute_source_index_set_grad(iy, inp_H, padding_mode, align_corners, &giy_mult);
iz = grid_sampler_compute_source_index_set_grad(iz, inp_D, padding_mode, align_corners, &giz_mult);
if (interpolation_mode == GridSamplerInterpolation::Bilinear) {
// get corner pixel values from (x, y, z)
// for 4d, we used north-east-south-west
// for 5d, we add top-bottom
int64_t ix_tnw = static_cast<int64_t>(std::floor(ix));
int64_t iy_tnw = static_cast<int64_t>(std::floor(iy));
int64_t iz_tnw = static_cast<int64_t>(std::floor(iz));
int64_t ix_tne = ix_tnw + 1;
int64_t iy_tne = iy_tnw;
int64_t iz_tne = iz_tnw;
int64_t ix_tsw = ix_tnw;
int64_t iy_tsw = iy_tnw + 1;
int64_t iz_tsw = iz_tnw;
int64_t ix_tse = ix_tnw + 1;
int64_t iy_tse = iy_tnw + 1;
int64_t iz_tse = iz_tnw;
int64_t ix_bnw = ix_tnw;
int64_t iy_bnw = iy_tnw;
int64_t iz_bnw = iz_tnw + 1;
int64_t ix_bne = ix_tnw + 1;
int64_t iy_bne = iy_tnw;
int64_t iz_bne = iz_tnw + 1;
int64_t ix_bsw = ix_tnw;
int64_t iy_bsw = iy_tnw + 1;
int64_t iz_bsw = iz_tnw + 1;
int64_t ix_bse = ix_tnw + 1;
int64_t iy_bse = iy_tnw + 1;
int64_t iz_bse = iz_tnw + 1;
// get surfaces to each neighbor:
scalar_t tnw = (ix_bse - ix) * (iy_bse - iy) * (iz_bse - iz);
scalar_t tne = (ix - ix_bsw) * (iy_bsw - iy) * (iz_bsw - iz);
scalar_t tsw = (ix_bne - ix) * (iy - iy_bne) * (iz_bne - iz);
scalar_t tse = (ix - ix_bnw) * (iy - iy_bnw) * (iz_bnw - iz);
scalar_t bnw = (ix_tse - ix) * (iy_tse - iy) * (iz - iz_tse);
scalar_t bne = (ix - ix_tsw) * (iy_tsw - iy) * (iz - iz_tsw);
scalar_t bsw = (ix_tne - ix) * (iy - iy_tne) * (iz - iz_tne);
scalar_t bse = (ix - ix_tnw) * (iy - iy_tnw) * (iz - iz_tnw);
scalar_t gix = static_cast<scalar_t>(0), giy = static_cast<scalar_t>(0), giz = static_cast<scalar_t>(0);
const scalar_t *gOut_ptr_NCDHW = gOut_ptr + n * gOut_sN + d * gOut_sD + h * gOut_sH + w * gOut_sW;
const scalar_t *inp_ptr_NC = inp_ptr_N;
scalar_t *gInp_ptr_NC = gInp_ptr + n * gInp_sN;
// calculate bilinear weighted pixel value and set output pixel
for (int64_t c = 0; c < C; ++c, gOut_ptr_NCDHW += gOut_sC, gInp_ptr_NC += gInp_sC, inp_ptr_NC += inp_sC) {
scalar_t gOut = *gOut_ptr_NCDHW;
// calculate and set grad_input
if (input_requires_grad) {
safe_add_3d(gInp_ptr_NC, iz_tnw, iy_tnw, ix_tnw, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, tnw * gOut);
safe_add_3d(gInp_ptr_NC, iz_tne, iy_tne, ix_tne, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, tne * gOut);
safe_add_3d(gInp_ptr_NC, iz_tsw, iy_tsw, ix_tsw, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, tsw * gOut);
safe_add_3d(gInp_ptr_NC, iz_tse, iy_tse, ix_tse, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, tse * gOut);
safe_add_3d(gInp_ptr_NC, iz_bnw, iy_bnw, ix_bnw, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, bnw * gOut);
safe_add_3d(gInp_ptr_NC, iz_bne, iy_bne, ix_bne, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, bne * gOut);
safe_add_3d(gInp_ptr_NC, iz_bsw, iy_bsw, ix_bsw, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, bsw * gOut);
safe_add_3d(gInp_ptr_NC, iz_bse, iy_bse, ix_bse, gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, bse * gOut);
}
// calculate grad_grid
if (within_bounds_3d(iz_tnw, iy_tnw, ix_tnw, inp_D, inp_H, inp_W)) {
scalar_t tnw_val = inp_ptr_NC[iz_tnw * inp_sD + iy_tnw * inp_sH + ix_tnw * inp_sW];
gix -= tnw_val * (iy_bse - iy) * (iz_bse - iz) * gOut;
giy -= tnw_val * (ix_bse - ix) * (iz_bse - iz) * gOut;
giz -= tnw_val * (ix_bse - ix) * (iy_bse - iy) * gOut;
}
if (within_bounds_3d(iz_tne, iy_tne, ix_tne, inp_D, inp_H, inp_W)) {
scalar_t tne_val = inp_ptr_NC[iz_tne * inp_sD + iy_tne * inp_sH + ix_tne * inp_sW];
gix += tne_val * (iy_bsw - iy) * (iz_bsw - iz) * gOut;
giy -= tne_val * (ix - ix_bsw) * (iz_bsw - iz) * gOut;
giz -= tne_val * (ix - ix_bsw) * (iy_bsw - iy) * gOut;
}
if (within_bounds_3d(iz_tsw, iy_tsw, ix_tsw, inp_D, inp_H, inp_W)) {
scalar_t tsw_val = inp_ptr_NC[iz_tsw * inp_sD + iy_tsw * inp_sH + ix_tsw * inp_sW];
gix -= tsw_val * (iy - iy_bne) * (iz_bne - iz) * gOut;
giy += tsw_val * (ix_bne - ix) * (iz_bne - iz) * gOut;
giz -= tsw_val * (ix_bne - ix) * (iy - iy_bne) * gOut;
}
if (within_bounds_3d(iz_tse, iy_tse, ix_tse, inp_D, inp_H, inp_W)) {
scalar_t tse_val = inp_ptr_NC[iz_tse * inp_sD + iy_tse * inp_sH + ix_tse * inp_sW];
gix += tse_val * (iy - iy_bnw) * (iz_bnw - iz) * gOut;
giy += tse_val * (ix - ix_bnw) * (iz_bnw - iz) * gOut;
giz -= tse_val * (ix - ix_bnw) * (iy - iy_bnw) * gOut;
}
if (within_bounds_3d(iz_bnw, iy_bnw, ix_bnw, inp_D, inp_H, inp_W)) {
scalar_t bnw_val = inp_ptr_NC[iz_bnw * inp_sD + iy_bnw * inp_sH + ix_bnw * inp_sW];
gix -= bnw_val * (iy_tse - iy) * (iz - iz_tse) * gOut;
giy -= bnw_val * (ix_tse - ix) * (iz - iz_tse) * gOut;
giz += bnw_val * (ix_tse - ix) * (iy_tse - iy) * gOut;
}
if (within_bounds_3d(iz_bne, iy_bne, ix_bne, inp_D, inp_H, inp_W)) {
scalar_t bne_val = inp_ptr_NC[iz_bne * inp_sD + iy_bne * inp_sH + ix_bne * inp_sW];
gix += bne_val * (iy_tsw - iy) * (iz - iz_tsw) * gOut;
giy -= bne_val * (ix - ix_tsw) * (iz - iz_tsw) * gOut;
giz += bne_val * (ix - ix_tsw) * (iy_tsw - iy) * gOut;
}
if (within_bounds_3d(iz_bsw, iy_bsw, ix_bsw, inp_D, inp_H, inp_W)) {
scalar_t bsw_val = inp_ptr_NC[iz_bsw * inp_sD + iy_bsw * inp_sH + ix_bsw * inp_sW];
gix -= bsw_val * (iy - iy_tne) * (iz - iz_tne) * gOut;
giy += bsw_val * (ix_tne - ix) * (iz - iz_tne) * gOut;
giz += bsw_val * (ix_tne - ix) * (iy - iy_tne) * gOut;
}
if (within_bounds_3d(iz_bse, iy_bse, ix_bse, inp_D, inp_H, inp_W)) {
scalar_t bse_val = inp_ptr_NC[iz_bse * inp_sD + iy_bse * inp_sH + ix_bse * inp_sW];
gix += bse_val * (iy - iy_tnw) * (iz - iz_tnw) * gOut;
giy += bse_val * (ix - ix_tnw) * (iz - iz_tnw) * gOut;
giz += bse_val * (ix - ix_tnw) * (iy - iy_tnw) * gOut;
}
}
// assuming grad_grid is contiguous
gGrid_ptr_NDHW[0] = gix_mult * gix;
gGrid_ptr_NDHW[1] = giy_mult * giy;
gGrid_ptr_NDHW[2] = giz_mult * giz;
} else if (interpolation_mode == GridSamplerInterpolation::Nearest) {
int64_t ix_nearest = static_cast<int64_t>(std::nearbyint(ix));
int64_t iy_nearest = static_cast<int64_t>(std::nearbyint(iy));
int64_t iz_nearest = static_cast<int64_t>(std::nearbyint(iz));
// assign nearest neighbour pixel value to output pixel
const scalar_t *gOut_ptr_NCDHW = gOut_ptr + n * gOut_sN + d * gOut_sD + h * gOut_sH + w * gOut_sW;
if (input_requires_grad) {
scalar_t *gInp_ptr_NC = gInp_ptr + n * gInp_sN;
for (int64_t c = 0; c < C; ++c, gOut_ptr_NCDHW += gOut_sC, gInp_ptr_NC += gInp_sC) {
// calculate and set grad_input
safe_add_3d(gInp_ptr_NC, iz_nearest, iy_nearest, ix_nearest,
gInp_sD, gInp_sH, gInp_sW, inp_D, inp_H, inp_W, *gOut_ptr_NCDHW);
}
}
}
}
}
}
}
});
return std::make_tuple(grad_input, grad_grid);
}
} // namespace
static Tensor _grid_sampler_2d_cpu_quantized(
const Tensor& input,
const Tensor& grid,
int64_t interpolation_mode_,
int64_t padding_mode_,
bool align_corners) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_2d(input, grid);
auto interpolation_mode =
static_cast<GridSamplerInterpolation>(interpolation_mode_);
/* Bilinear interpolation is supported using the fact that we can perform
* linear interpolations on quantized values without rescaling. */
TORCH_CHECK(
interpolation_mode == GridSamplerInterpolation::Bilinear,
"_grid_sampler_2d_cpu_quantized(): only bilinear interpolation supported")
auto padding_mode = static_cast<GridSamplerPadding>(padding_mode_);
int64_t N = input.size(0);
int64_t C = input.size(1);
int64_t inp_H = input.size(2);
int64_t inp_W = input.size(3);
int64_t out_H = grid.size(1);
int64_t out_W = grid.size(2);
uint8_t zero_point = input.q_zero_point();
auto output = at::_empty_affine_quantized(
{N, C, out_H, out_W},
at::device(c10::kCPU).dtype(c10::kQUInt8),
input.q_scale(),
zero_point);
int64_t inp_sN = input.stride(0);
int64_t inp_sC = input.stride(1);
int64_t inp_sH = input.stride(2);
int64_t inp_sW = input.stride(3);
int64_t grid_sN = grid.stride(0);
int64_t grid_sH = grid.stride(1);
int64_t grid_sW = grid.stride(2);
int64_t grid_sCoor = grid.stride(3);
int64_t out_sN = output.stride(0);
int64_t out_sC = output.stride(1);
int64_t out_sH = output.stride(2);
int64_t out_sW = output.stride(3);
uint8_t* inp_ptr = (uint8_t*)input.data_ptr<quint8>();
uint8_t* out_ptr = (uint8_t*)output.data_ptr<quint8>();
float* grid_ptr = grid.data_ptr<float>();
at::parallel_for(0, N, 0, [&](int64_t start, int64_t end) {
for (const auto n : c10::irange(start, end)) {
float* grid_ptr_N = grid_ptr + n * grid_sN;
uint8_t* inp_ptr_N = inp_ptr + n * inp_sN;
for (const auto h : c10::irange(out_H)) {
for (const auto w : c10::irange(out_W)) {
// get the corresponding input x, y, z co-ordinates from grid
float* grid_ptr_NHW = grid_ptr_N + h * grid_sH + w * grid_sW;
float x = *grid_ptr_NHW;
float y = grid_ptr_NHW[grid_sCoor];
float ix = grid_sampler_compute_source_index(
x, inp_W, padding_mode, align_corners);
float iy = grid_sampler_compute_source_index(
y, inp_H, padding_mode, align_corners);
// get corner pixel values from (x, y)
// for 4d, we use north-east-south-west
int64_t ix_nw = static_cast<int64_t>(std::floor(ix));
int64_t iy_nw = static_cast<int64_t>(std::floor(iy));
int64_t ix_ne = ix_nw + 1;
int64_t iy_ne = iy_nw;
int64_t ix_sw = ix_nw;
int64_t iy_sw = iy_nw + 1;
int64_t ix_se = ix_nw + 1;
int64_t iy_se = iy_nw + 1;
// get surfaces to each neighbor:
float nw = (ix_se - ix) * (iy_se - iy);
float ne = (ix - ix_sw) * (iy_sw - iy);
float sw = (ix_ne - ix) * (iy - iy_ne);
float se = (ix - ix_nw) * (iy - iy_nw);
// calculate bilinear weighted pixel value and set output pixel
uint8_t* inp_ptr_NC = inp_ptr_N;
uint8_t* out_ptr_NCHW =
out_ptr + n * out_sN + h * out_sH + w * out_sW;
for (int64_t c = 0; c < C;
++c, out_ptr_NCHW += out_sC, inp_ptr_NC += inp_sC) {
float res = 0;
res += within_bounds_2d(iy_nw, ix_nw, inp_H, inp_W)
? inp_ptr_NC[iy_nw * inp_sH + ix_nw * inp_sW] * nw
: zero_point * nw;
res += within_bounds_2d(iy_ne, ix_ne, inp_H, inp_W)
? inp_ptr_NC[iy_ne * inp_sH + ix_ne * inp_sW] * ne
: zero_point * ne;
res += within_bounds_2d(iy_sw, ix_sw, inp_H, inp_W)
? inp_ptr_NC[iy_sw * inp_sH + ix_sw * inp_sW] * sw
: zero_point * sw;
res += within_bounds_2d(iy_se, ix_se, inp_H, inp_W)
? inp_ptr_NC[iy_se * inp_sH + ix_se * inp_sW] * se
: zero_point * se;
*out_ptr_NCHW = std::nearbyint(res);
}
}
}
}
});
return output;
}
Tensor _grid_sampler_2d_cpu_fallback(const Tensor& input, const Tensor& grid,
int64_t interpolation_mode_,
int64_t padding_mode_,
bool align_corners) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_2d(input, grid);
auto interpolation_mode = static_cast<GridSamplerInterpolation>(interpolation_mode_);
auto padding_mode = static_cast<GridSamplerPadding>(padding_mode_);
using scalar_t = float;
int64_t N = input.size(0);
int64_t C = input.size(1);
int64_t inp_H = input.size(2);
int64_t inp_W = input.size(3);
int64_t out_H = grid.size(1);
int64_t out_W = grid.size(2);
auto output = at::empty({N, C, out_H, out_W}, input.options());
if (output.numel() == 0) {
return output;
}
int64_t inp_sN = input.stride(0);
int64_t inp_sC = input.stride(1);
int64_t inp_sH = input.stride(2);
int64_t inp_sW = input.stride(3);
int64_t grid_sN = grid.stride(0);
int64_t grid_sH = grid.stride(1);
int64_t grid_sW = grid.stride(2);
int64_t grid_sCoor = grid.stride(3);
int64_t out_sN = output.stride(0);
int64_t out_sC = output.stride(1);
int64_t out_sH = output.stride(2);
int64_t out_sW = output.stride(3);
const scalar_t *inp_ptr = input.const_data_ptr<scalar_t>();
scalar_t *out_ptr = output.data_ptr<scalar_t>();
const scalar_t *grid_ptr = grid.const_data_ptr<scalar_t>();
// loop over each output pixel
at::parallel_for(0, N, 0, [&](int64_t start, int64_t end) {
for (const auto n : c10::irange(start, end)) {
const scalar_t *grid_ptr_N = grid_ptr + n * grid_sN;
const scalar_t *inp_ptr_N = inp_ptr + n * inp_sN;
for (const auto h : c10::irange(out_H)) {
for (const auto w : c10::irange(out_W)) {
// get the corresponding input x, y, z co-ordinates from grid
const scalar_t *grid_ptr_NHW = grid_ptr_N + h * grid_sH + w * grid_sW;
scalar_t x = *grid_ptr_NHW;
scalar_t y = grid_ptr_NHW[grid_sCoor];
scalar_t ix = grid_sampler_compute_source_index(x, inp_W, padding_mode, align_corners);
scalar_t iy = grid_sampler_compute_source_index(y, inp_H, padding_mode, align_corners);
if (interpolation_mode == GridSamplerInterpolation::Bilinear) {
// get corner pixel values from (x, y)
// for 4d, we use north-east-south-west
int64_t ix_nw = static_cast<int64_t>(std::floor(ix));
int64_t iy_nw = static_cast<int64_t>(std::floor(iy));
int64_t ix_ne = ix_nw + 1;
int64_t iy_ne = iy_nw;
int64_t ix_sw = ix_nw;
int64_t iy_sw = iy_nw + 1;
int64_t ix_se = ix_nw + 1;
int64_t iy_se = iy_nw + 1;
// get surfaces to each neighbor:
scalar_t nw = (ix_se - ix) * (iy_se - iy);
scalar_t ne = (ix - ix_sw) * (iy_sw - iy);
scalar_t sw = (ix_ne - ix) * (iy - iy_ne);
scalar_t se = (ix - ix_nw) * (iy - iy_nw);
// calculate bilinear weighted pixel value and set output pixel
const scalar_t *inp_ptr_NC = inp_ptr_N;
scalar_t *out_ptr_NCHW = out_ptr + n * out_sN + h * out_sH + w * out_sW;
for (int64_t c = 0; c < C; ++c, out_ptr_NCHW += out_sC, inp_ptr_NC += inp_sC) {
auto res = static_cast<scalar_t>(0);
if (within_bounds_2d(iy_nw, ix_nw, inp_H, inp_W)) {
res += inp_ptr_NC[iy_nw * inp_sH + ix_nw * inp_sW] * nw;
}
if (within_bounds_2d(iy_ne, ix_ne, inp_H, inp_W)) {
res += inp_ptr_NC[iy_ne * inp_sH + ix_ne * inp_sW] * ne;
}
if (within_bounds_2d(iy_sw, ix_sw, inp_H, inp_W)) {
res += inp_ptr_NC[iy_sw * inp_sH + ix_sw * inp_sW] * sw;
}
if (within_bounds_2d(iy_se, ix_se, inp_H, inp_W)) {
res += inp_ptr_NC[iy_se * inp_sH + ix_se * inp_sW] * se;
}
*out_ptr_NCHW = res;
}
} else if (interpolation_mode == GridSamplerInterpolation::Nearest) {
int64_t ix_nearest = static_cast<int64_t>(std::nearbyint(ix));
int64_t iy_nearest = static_cast<int64_t>(std::nearbyint(iy));
// assign nearest neighbour pixel value to output pixel
scalar_t *out_ptr_NCHW = out_ptr + n * out_sN + h * out_sH + w * out_sW;
const scalar_t *inp_ptr_NC = inp_ptr_N;
for (int64_t c = 0; c < C; ++c, out_ptr_NCHW += out_sC, inp_ptr_NC += inp_sC) {
if (within_bounds_2d(iy_nearest, ix_nearest, inp_H, inp_W)) {
*out_ptr_NCHW = inp_ptr_NC[iy_nearest * inp_sH + ix_nearest * inp_sW];
} else {
*out_ptr_NCHW = static_cast<scalar_t>(0);
}
}
} else if (interpolation_mode == GridSamplerInterpolation::Bicubic) {
// grid_sampler_compute_source_index will "clip the value" of idx depends on the padding,
// which would cause calculation to be wrong,
// for example x = -0.1 -> ix = 0 for zero padding, but in bicubic ix = floor(x) = -1
// There would be more problem in reflection padding, since the -1 and +1 direction is not fixed in boundary condition
ix = grid_sampler_unnormalize(x, inp_W, align_corners);
iy = grid_sampler_unnormalize(y, inp_H, align_corners);
scalar_t ix_nw = std::floor(ix);
scalar_t iy_nw = std::floor(iy);
const scalar_t tx = ix - ix_nw;
const scalar_t ty = iy - iy_nw;
const scalar_t *inp_ptr_NC = inp_ptr_N;
scalar_t *out_ptr_NCHW = out_ptr + n * out_sN + h * out_sH + w * out_sW;
for (int64_t c = 0; c < C; ++c, out_ptr_NCHW += out_sC, inp_ptr_NC += inp_sC) {
// NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
scalar_t coefficients[4];
// Interpolate 4 values in the x direction
for (const auto i : c10::irange(4)) {
coefficients[i] = cubic_interp1d<scalar_t>(
get_value_bounded<scalar_t>(inp_ptr_NC, ix_nw - 1, iy_nw - 1 + i, inp_W, inp_H, inp_sW, inp_sH, padding_mode, align_corners),
get_value_bounded<scalar_t>(inp_ptr_NC, ix_nw + 0, iy_nw - 1 + i, inp_W, inp_H, inp_sW, inp_sH, padding_mode, align_corners),
get_value_bounded<scalar_t>(inp_ptr_NC, ix_nw + 1, iy_nw - 1 + i, inp_W, inp_H, inp_sW, inp_sH, padding_mode, align_corners),
get_value_bounded<scalar_t>(inp_ptr_NC, ix_nw + 2, iy_nw - 1 + i, inp_W, inp_H, inp_sW, inp_sH, padding_mode, align_corners),
tx);
}
// Interpolate in the y direction
*out_ptr_NCHW = cubic_interp1d<scalar_t>(
coefficients[0],
coefficients[1],
coefficients[2],
coefficients[3],
ty);
}
}
}
}
}
});
return output;
}
std::tuple<Tensor, Tensor>
_grid_sampler_2d_cpu_fallback_backward(const Tensor& grad_output,
const Tensor& input, const Tensor& grid,
int64_t interpolation_mode_,
int64_t padding_mode_,
bool align_corners) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_2d(input, grid);
const auto interpolation_mode = static_cast<GridSamplerInterpolation>(interpolation_mode_);
const auto padding_mode = static_cast<GridSamplerPadding>(padding_mode_);
using scalar_t = float;
auto grad_input = at::zeros_like(input, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
auto grad_grid = at::empty_like(grid, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
if (grid.numel() == 0 || input.numel() == 0) {
grad_grid.zero_();
return std::make_tuple(grad_input, grad_grid);
}
// If interpolation mode is Nearest, then grad_grid is not filled in the
// loop below.
if (interpolation_mode == GridSamplerInterpolation::Nearest) {
grad_grid.zero_();
}
int64_t N = input.size(0);
int64_t C = input.size(1);
int64_t inp_H = input.size(2);
int64_t inp_W = input.size(3);
int64_t out_H = grid.size(1);
int64_t out_W = grid.size(2);
int64_t inp_sN = input.stride(0);
int64_t inp_sC = input.stride(1);
int64_t inp_sH = input.stride(2);
int64_t inp_sW = input.stride(3);
int64_t grid_sN = grid.stride(0);
int64_t grid_sH = grid.stride(1);
int64_t grid_sW = grid.stride(2);
int64_t grid_sCoor = grid.stride(3);
int64_t gOut_sN = grad_output.stride(0);
int64_t gOut_sC = grad_output.stride(1);
int64_t gOut_sH = grad_output.stride(2);
int64_t gOut_sW = grad_output.stride(3);
int64_t gInp_sN = grad_input.stride(0);
int64_t gInp_sC = grad_input.stride(1);
int64_t gInp_sH = grad_input.stride(2);
int64_t gInp_sW = grad_input.stride(3);
int64_t gGrid_sN = grad_grid.stride(0);
int64_t gGrid_sW = grad_grid.stride(2);
const scalar_t *inp_ptr = input.const_data_ptr<scalar_t>();
const scalar_t *grid_ptr = grid.const_data_ptr<scalar_t>();
const scalar_t *gOut_ptr = grad_output.const_data_ptr<scalar_t>();
scalar_t *gInp_ptr = grad_input.mutable_data_ptr<scalar_t>();
scalar_t *gGrid_ptr = grad_grid.data_ptr<scalar_t>();
// loop over each output pixel
at::parallel_for(0, N, 0, [&](int64_t start, int64_t end) {
for (const auto n : c10::irange(start, end)) {
const scalar_t *grid_ptr_N = grid_ptr + n * grid_sN;
const scalar_t *inp_ptr_N = inp_ptr + n * inp_sN;
scalar_t *gGrid_ptr_NHW = gGrid_ptr + n * gGrid_sN;
for (const auto h : c10::irange(out_H)) {
for (int64_t w = 0; w < out_W; ++w, gGrid_ptr_NHW += gGrid_sW /* grad_grid is contiguous */ ) {
// get the corresponding input x, y co-ordinates from grid
const scalar_t *grid_ptr_NHW = grid_ptr_N + h * grid_sH + w * grid_sW;
scalar_t x = *grid_ptr_NHW;
scalar_t y = grid_ptr_NHW[grid_sCoor];
// multipliers for gradients on ix, iy
// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
scalar_t gix_mult, giy_mult;
scalar_t ix = grid_sampler_compute_source_index_set_grad(x, inp_W, padding_mode, align_corners, &gix_mult);
scalar_t iy = grid_sampler_compute_source_index_set_grad(y, inp_H, padding_mode, align_corners, &giy_mult);
if (interpolation_mode == GridSamplerInterpolation::Bilinear) {
// get corner pixel values from (x, y)
// for 4d, we use north-east-south-west
int64_t ix_nw = static_cast<int64_t>(std::floor(ix));
int64_t iy_nw = static_cast<int64_t>(std::floor(iy));
int64_t ix_ne = ix_nw + 1;
int64_t iy_ne = iy_nw;
int64_t ix_sw = ix_nw;
int64_t iy_sw = iy_nw + 1;
int64_t ix_se = ix_nw + 1;
int64_t iy_se = iy_nw + 1;
// get surfaces to each neighbor:
scalar_t nw = (ix_se - ix) * (iy_se - iy);
scalar_t ne = (ix - ix_sw) * (iy_sw - iy);
scalar_t sw = (ix_ne - ix) * (iy - iy_ne);
scalar_t se = (ix - ix_nw) * (iy - iy_nw);
scalar_t gix = static_cast<scalar_t>(0), giy = static_cast<scalar_t>(0);
const scalar_t *gOut_ptr_NCHW = gOut_ptr + n * gOut_sN + h * gOut_sH + w * gOut_sW;
scalar_t *gInp_ptr_NC = gInp_ptr + n * gInp_sN;
const scalar_t *inp_ptr_NC = inp_ptr_N;
// calculate bilinear weighted pixel value and set output pixel
for (int64_t c = 0; c < C; ++c, gOut_ptr_NCHW += gOut_sC, gInp_ptr_NC += gInp_sC, inp_ptr_NC += inp_sC) {
scalar_t gOut = *gOut_ptr_NCHW;
// calculate and set grad_input
safe_add_2d(gInp_ptr_NC, iy_nw, ix_nw, gInp_sH, gInp_sW, inp_H, inp_W, nw * gOut);
safe_add_2d(gInp_ptr_NC, iy_ne, ix_ne, gInp_sH, gInp_sW, inp_H, inp_W, ne * gOut);
safe_add_2d(gInp_ptr_NC, iy_sw, ix_sw, gInp_sH, gInp_sW, inp_H, inp_W, sw * gOut);
safe_add_2d(gInp_ptr_NC, iy_se, ix_se, gInp_sH, gInp_sW, inp_H, inp_W, se * gOut);
// calculate grad_grid
if (within_bounds_2d(iy_nw, ix_nw, inp_H, inp_W)) {
scalar_t nw_val = inp_ptr_NC[iy_nw * inp_sH + ix_nw * inp_sW];
gix -= nw_val * (iy_se - iy) * gOut;
giy -= nw_val * (ix_se - ix) * gOut;
}
if (within_bounds_2d(iy_ne, ix_ne, inp_H, inp_W)) {
scalar_t ne_val = inp_ptr_NC[iy_ne * inp_sH + ix_ne * inp_sW];
gix += ne_val * (iy_sw - iy) * gOut;
giy -= ne_val * (ix - ix_sw) * gOut;
}
if (within_bounds_2d(iy_sw, ix_sw, inp_H, inp_W)) {
scalar_t sw_val = inp_ptr_NC[iy_sw * inp_sH + ix_sw * inp_sW];
gix -= sw_val * (iy - iy_ne) * gOut;
giy += sw_val * (ix_ne - ix) * gOut;
}
if (within_bounds_2d(iy_se, ix_se, inp_H, inp_W)) {
scalar_t se_val = inp_ptr_NC[iy_se * inp_sH + ix_se * inp_sW];
gix += se_val * (iy - iy_nw) * gOut;
giy += se_val * (ix - ix_nw) * gOut;
}
}
// assuming grad_grid is contiguous
gGrid_ptr_NHW[0] = gix_mult * gix;
gGrid_ptr_NHW[1] = giy_mult * giy;
} else if (interpolation_mode == GridSamplerInterpolation::Nearest) {
int64_t ix_nearest = static_cast<int64_t>(std::nearbyint(ix));
int64_t iy_nearest = static_cast<int64_t>(std::nearbyint(iy));
// assign nearest neighbour pixel value to output pixel
const scalar_t *gOut_ptr_NCHW = gOut_ptr + n * gOut_sN + h * gOut_sH + w * gOut_sW;
scalar_t *gInp_ptr_NC = gInp_ptr + n * gInp_sN;
for (int64_t c = 0; c < C; ++c, gOut_ptr_NCHW += gOut_sC, gInp_ptr_NC += gInp_sC) {
// calculate and set grad_input
safe_add_2d(gInp_ptr_NC, iy_nearest, ix_nearest, gInp_sH, gInp_sW,
inp_H, inp_W, *gOut_ptr_NCHW);
}
} else if (interpolation_mode == GridSamplerInterpolation::Bicubic) {
ix = grid_sampler_unnormalize_set_grad(x, inp_W, align_corners, &gix_mult);
iy = grid_sampler_unnormalize_set_grad(y, inp_H, align_corners, &giy_mult);
scalar_t ix_nw = std::floor(ix);
scalar_t iy_nw = std::floor(iy);
const scalar_t tx = ix - ix_nw;
const scalar_t ty = iy - iy_nw;
// NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
scalar_t x_coeffs[4];
// NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
scalar_t y_coeffs[4];
// NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
scalar_t x_coeffs_grad[4];
// NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
scalar_t y_coeffs_grad[4];
get_cubic_upsample_coefficients<scalar_t>(x_coeffs, tx);
get_cubic_upsample_coefficients<scalar_t>(y_coeffs, ty);
get_cubic_coefficients_grad<scalar_t>(x_coeffs_grad, tx);
get_cubic_coefficients_grad<scalar_t>(y_coeffs_grad, ty);
scalar_t gix = static_cast<scalar_t>(0);
scalar_t giy = static_cast<scalar_t>(0);
const scalar_t *gOut_ptr_NCHW = gOut_ptr + n * gOut_sN + h * gOut_sH + w * gOut_sW;
scalar_t *gInp_ptr_NC = gInp_ptr + n * gInp_sN;
const scalar_t *inp_ptr_NC = inp_ptr_N;
for (int64_t c = 0; c < C; ++c, gOut_ptr_NCHW += gOut_sC, gInp_ptr_NC += gInp_sC, inp_ptr_NC+= inp_sC) {
scalar_t gOut = *gOut_ptr_NCHW;
for (const auto i : c10::irange(4)) {
for (const auto j : c10::irange(4)) {
// set input gradient
add_value_bounded<scalar_t>(gInp_ptr_NC, ix_nw - 1 + i, iy_nw - 1 + j,
inp_W, inp_H, gInp_sW, gInp_sH, gOut * x_coeffs[i] * y_coeffs[j], padding_mode, align_corners);
// set grid gradient
scalar_t val = get_value_bounded<scalar_t>(inp_ptr_NC, ix_nw - 1 + i, iy_nw - 1 + j,
inp_W, inp_H, inp_sW, inp_sH, padding_mode, align_corners);
gix -= val * x_coeffs_grad[i] * y_coeffs[j] * gOut;
giy -= val * y_coeffs_grad[j] * x_coeffs[i] * gOut;
}
}
}
gGrid_ptr_NHW[0] = gix_mult * gix;
gGrid_ptr_NHW[1] = giy_mult * giy;
}
}
}
}
});
return std::make_tuple(grad_input, grad_grid);
}
Tensor grid_sampler_2d_cpu(const Tensor& input, const Tensor& grid,
int64_t interpolation_mode, int64_t padding_mode,
bool align_corners) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_2d(input, grid);
if (input.scalar_type() == kQUInt8) {
return native::_grid_sampler_2d_cpu_quantized(
input, grid, interpolation_mode, padding_mode, align_corners);
}
// AVX gather instructions use signed 32-bit offsets to gather float values.
// Check for possible overflow and fallback to scalar implementation
if (input.scalar_type() != kDouble) {
TORCH_CHECK(input.scalar_type() == kFloat,
"grid_sampler_2d_cpu not implemented for ", input.scalar_type());
auto sizes = input.sizes();
auto strides = input.strides();
const auto grid_sW = grid.strides()[2];
// NOTE: Gather offsets are only used for the input H, W dimensions
// or only for strided access to the grid tensor
auto max_gather_offset = std::max(
(sizes[2] - 1) * strides[2] + (sizes[3] - 1) * strides[3],
grid_sW * (vec::Vectorized<float>::size() - 1));
if (max_gather_offset > std::numeric_limits<int32_t>::max()) {
return native::_grid_sampler_2d_cpu_fallback(
input, grid, interpolation_mode, padding_mode, align_corners);
}
}
auto in_size = input.sizes();
auto grid_size = grid.sizes();
auto output = at::empty(
{in_size[0], in_size[1], grid_size[1], grid_size[2]}, input.options());
grid_sampler_2d_cpu_kernel(
kCPU, output, input, grid, interpolation_mode, padding_mode, align_corners);
return output;
}
DEFINE_DISPATCH(grid_sampler_2d_cpu_kernel);
Tensor grid_sampler_3d_cpu(const Tensor& input, const Tensor& grid,
int64_t interpolation_mode, int64_t padding_mode,
bool align_corners) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_3d(input, grid, interpolation_mode);
return AT_DISPATCH_FLOATING_TYPES(input.scalar_type(), "grid_sampler3d_cpu", [&] {
return grid_sampler_3d_cpu_impl<scalar_t>(
input, grid, static_cast<GridSamplerInterpolation>(interpolation_mode),
static_cast<GridSamplerPadding>(padding_mode), align_corners);
});
}
std::tuple<Tensor, Tensor>
grid_sampler_2d_backward_cpu(const Tensor& grad_output, const Tensor& input, const Tensor& grid,
int64_t interpolation_mode, int64_t padding_mode, bool align_corners,
std::array<bool,2> output_mask) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_2d(input, grid);
// AVX gather instructions use signed 32-bit offsets to gather float values.
// Check for possible overflow and fallback to scalar implementation
if (input.scalar_type() != kDouble) {
TORCH_CHECK(input.scalar_type() == kFloat,
"grid_sampler_2d_backward_cpu not implemented for ", input.scalar_type());
auto isizes = input.sizes();
auto istrides = input.strides();
auto gsizes = grad_output.sizes();
auto gstrides = grad_output.strides();
const auto grid_sW = grid.strides()[2];
// NOTE: Gather offsets are only used for the height and width dimensions
auto max_gather_offset = std::max(
std::max(
(isizes[2] - 1) * istrides[2] + (isizes[3] - 1) * istrides[3],
(gsizes[2] - 1) * gstrides[2] + (gsizes[3] - 1) * gstrides[3]),
grid_sW * (vec::Vectorized<float>::size() - 1));
if (max_gather_offset > std::numeric_limits<int32_t>::max()) {
return native::_grid_sampler_2d_cpu_fallback_backward(
grad_output, input, grid, interpolation_mode, padding_mode, align_corners);
}
}
auto input_requires_grad = output_mask[0];
Tensor grad_input = ([&]() {
if (input_requires_grad) {
return at::zeros_like(input, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
} else {
return Tensor();
}
})();
auto grad_grid = at::empty_like(grid, LEGACY_CONTIGUOUS_MEMORY_FORMAT);
grid_sampler_2d_backward_cpu_kernel(
kCPU, grad_input, grad_grid, grad_output, input, grid,
interpolation_mode, padding_mode, align_corners, output_mask);
return std::make_tuple(std::move(grad_input), std::move(grad_grid));
}
DEFINE_DISPATCH(grid_sampler_2d_backward_cpu_kernel);
std::tuple<Tensor, Tensor>
grid_sampler_3d_backward_cpu(const Tensor& grad_output, const Tensor& input, const Tensor& grid,
int64_t interpolation_mode, int64_t padding_mode, bool align_corners,
std::array<bool,2> output_mask) {
// See NOTE [ grid_sampler Native Functions ].
// Add checks here in case this is called instead of grid_sampler.
check_grid_sampler_common(input, grid);
check_grid_sampler_3d(input, grid, interpolation_mode);
return AT_DISPATCH_FLOATING_TYPES(input.scalar_type(), "grid_sampler_3d_backward_cpu", [&] {
return grid_sampler_3d_backward_cpu_impl<scalar_t>(
grad_output, input, grid,
static_cast<GridSamplerInterpolation>(interpolation_mode),
static_cast<GridSamplerPadding>(padding_mode),
align_corners, output_mask);
});
}
// See NOTE [ grid_sampler Native Functions ].
Tensor grid_sampler(
const Tensor& input,
const Tensor& grid,
int64_t interpolation_mode,
int64_t padding_mode,
bool align_corners
) {
if (cond_cudnn_grid_sampler(input, grid) &&
static_cast<GridSamplerInterpolation>(interpolation_mode) ==
GridSamplerInterpolation::Bilinear &&
static_cast<GridSamplerPadding>(padding_mode) ==
GridSamplerPadding::Zeros &&
align_corners) {
return cudnn_grid_sampler(input, grid);
}
if (input.dim() == 4) {
return at::grid_sampler_2d(
input, grid, interpolation_mode, padding_mode, align_corners);
} else {
return at::grid_sampler_3d(
input, grid, interpolation_mode, padding_mode, align_corners);
}
}
} // namespace at::native
```
|
The Pinhook Methodist Church and Cemetery are located in New Durham Township, LaPorte County, Indiana at Wozniak Road with State Road 2. Known as the village of Pinhook, formerly New Durham. The village is mostly residential along the south side of State Road 2. The site includes the Pinhook Methodist Church (1847), the Pinhook Cemetery (1850), the cemetery storage shed (ca. 1900), and the old pump (ca. 1930).
Methodist Church
The frame church building constructed as a one-room, single story clapboard structure in a simple Greek Revival style in 1847. An early vestibule addition was constructed on the front of the building, ca. 1880, inset from the main building facade. The building sits on an orange/red brick foundation rising about above grade. The roof has wood shingles. A brick chimney extends from the ridge of the roof near the front of the main building. The building siding and trim is painted white with dark green windows, shutters and front door.
The front (south) facade is symmetrically with the vestibule projecting from the main building. Above the front door is a wood sign with the name of the church and year of construction. The corner boards on the main building, in keeping with the Greek-Revival style however, terminate at the horizontal entablature wrapping around from the east and west facades, with decorative trim making the appearance of a pilaster cap. The frieze board of the gable then extends up the face of the gable from this horizontal detail. A cove trim piece is located at the juncture of the frieze board and wood soffit of the eave.
Pinhook Cemetery
The Pinhook Cemetery, established in 1850, is divided into four sections with a single gravel road entering off of State Road 2 near the intersection of Wozniak Road and exiting onto Wozniak Road on its east boundary. It is bordered by State Road 2 on the south, Wozniak Road on the east, and agricultural tilled lands on the north and west. The church is located in its southwest corner. State Road 2 forms a gentle curve northward from the west edge of the cemetery to Wozniak Road. The cemetery is fenced on the east side, and partially on the south side, by a white vinyl picket fence. Newer brick piers flank the entrance and exit. Several mature deciduous and cedar trees are located in the cemetery.
Cemetery Storage Shed
The storage shed is a ca. 1900 small frame building, approximately eight feet wide by twelve feet deep, facing east with a single vertical wood plank door in the center and simple straight stock wood casings on the east facade. The building rests on a concrete block foundation, having been relocated to this site from the center of the cemetery near the pump. The shed is covered with narrow wood clapboard siding and wood corner boards. A single four-pane fixed wood window is located on the north and south facades also with simple straight stock casings; there are no openings on the west facade. The building has a gable roof, with the gable facing east, made of asphalt shingles. There is a vent pipe on the north half of the roof. The shed is in good condition.
Pump
A metal hand water pump, ca. 1930, is located near the center of the cemetery along the main drive. The base around the pump is constructed of treated wood 2x6 materials, the pump rising out of the center of the platform. The pump is made of cast pieces, with the manufacturer's name and city on the east side of the shaft "Baker Mfg. Co. Evansville, Wis." and the pump model name on the west side "Monitor". The pump is in good condition.
Bibliography
Alt, Julie. Pinhook Church Historical Research Notes and Recollections. Unpublished manuscript, collection of Julie Alt.
Cannon, Thomas Harvey. The History of Lake and Calumet Region of Indiana. Vol. 1. Indianapolis: Historian's Association, 1927
History of LaPorte County. Indiana. Chicago: Charles C. Chapman & Co., 1880.
Indiana Historic Sites and Structures Inventory. LaPorte County Interim Report. LaPorte, IN:Office of Community Planning and Development, 2002.
Packard, Jasper. History of LaPorte County. Indiana, and its Townships. Towns, and Cities. LaPorte, IN: S.E. Taylor & Co., 1876.
Taylor, Robert M. et al. Indiana. A New Historical Guide. Indianapolis: Indiana Historical Society, 1989.
References
Churches on the National Register of Historic Places in Indiana
Greek Revival church buildings in Indiana
Churches completed in 1847
Wooden churches in the United States
1847 establishments in Indiana
National Register of Historic Places in LaPorte County, Indiana
|
Ługi is a village in the administrative district of Gmina Zakrzewo, within Złotów County, Greater Poland Voivodeship, in west-central Poland.
For more on its history, see Złotów County.
References
Villages in Złotów County
|
```python
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# ==============================================================================
"""Composes one or more `LinearOperators`."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from tensorflow.contrib.linalg.python.ops import linear_operator
from tensorflow.python.framework import common_shapes
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import check_ops
__all__ = ["LinearOperatorComposition"]
class LinearOperatorComposition(linear_operator.LinearOperator):
"""Composes one or more `LinearOperators`.
This operator composes one or more linear operators `[op1,...,opJ]`,
building a new `LinearOperator` with action defined by:
```
op_composed(x) := op1(op2(...(opJ(x)...))
```
If `opj` acts like [batch] matrix `Aj`, then `op_composed` acts like the
[batch] matrix formed with the multiplication `A1 A2...AJ`.
If `opj` has shape `batch_shape_j + [M_j, N_j]`, then we must have
`N_j = M_{j+1}`, in which case the composed operator has shape equal to
`broadcast_batch_shape + [M_1, N_J]`, where `broadcast_batch_shape` is the
mutual broadcast of `batch_shape_j`, `j = 1,...,J`, assuming the intermediate
batch shapes broadcast. Even if the composed shape is well defined, the
composed operator's methods may fail due to lack of broadcasting ability in
the defining operators' methods.
```python
# Create a 2 x 2 linear operator composed of two 2 x 2 operators.
operator_1 = LinearOperatorFullMatrix([[1., 2.], [3., 4.]])
operator_2 = LinearOperatorFullMatrix([[1., 0.], [0., 1.]])
operator = LinearOperatorComposition([operator_1, operator_2])
operator.to_dense()
==> [[1., 2.]
[3., 4.]]
operator.shape
==> [2, 2]
operator.log_abs_determinant()
==> scalar Tensor
x = ... Shape [2, 4] Tensor
operator.matmul(x)
==> Shape [2, 4] Tensor
# Create a [2, 3] batch of 4 x 5 linear operators.
matrix_45 = tf.random_normal(shape=[2, 3, 4, 5])
operator_45 = LinearOperatorFullMatrix(matrix)
# Create a [2, 3] batch of 5 x 6 linear operators.
matrix_56 = tf.random_normal(shape=[2, 3, 5, 6])
operator_56 = LinearOperatorFullMatrix(matrix_56)
# Compose to create a [2, 3] batch of 4 x 6 operators.
opeartor_46 = LinearOperatorComposition([operator_45, operator_56])
# Create a shape [2, 3, 6, 2] vector.
x = tf.random_normal(shape=[2, 3, 6, 2])
operator.matmul(x)
==> Shape [2, 3, 4, 2] Tensor
```
#### Performance
The performance of `LinearOperatorComposition` on any operation is equal to
the sum of the individual operators' operations.
#### Matrix property hints
This `LinearOperator` is initialized with boolean flags of the form `is_X`,
for `X = non_singular, self_adjoint, positive_definite, square`.
These have the following meaning
* If `is_X == True`, callers should expect the operator to have the
property `X`. This is a promise that should be fulfilled, but is *not* a
runtime assert. For example, finite floating point precision may result
in these promises being violated.
* If `is_X == False`, callers should expect the operator to not have `X`.
* If `is_X == None` (the default), callers should have no expectation either
way.
"""
def __init__(self,
operators,
is_non_singular=None,
is_self_adjoint=None,
is_positive_definite=None,
is_square=None,
name=None):
r"""Initialize a `LinearOperatorComposition`.
`LinearOperatorComposition` is initialized with a list of operators
`[op_1,...,op_J]`. For the `matmul` method to be well defined, the
composition `op_i.matmul(op_{i+1}(x))` must be defined. Other methods have
similar constraints.
Args:
operators: Iterable of `LinearOperator` objects, each with
the same `dtype` and composable shape.
is_non_singular: Expect that this operator is non-singular.
is_self_adjoint: Expect that this operator is equal to its hermitian
transpose.
is_positive_definite: Expect that this operator is positive definite,
meaning the quadratic form `x^H A x` has positive real part for all
nonzero `x`. Note that we do not require the operator to be
self-adjoint to be positive-definite. See:
path_to_url
#Extension_for_non_symmetric_matrices
is_square: Expect that this operator acts like square [batch] matrices.
name: A name for this `LinearOperator`. Default is the individual
operators names joined with `_o_`.
Raises:
TypeError: If all operators do not have the same `dtype`.
ValueError: If `operators` is empty.
"""
# Validate operators.
check_ops.assert_proper_iterable(operators)
operators = list(operators)
if not operators:
raise ValueError(
"Expected a non-empty list of operators. Found: %s" % operators)
self._operators = operators
# Validate dtype.
dtype = operators[0].dtype
for operator in operators:
if operator.dtype != dtype:
name_type = (str((o.name, o.dtype)) for o in operators)
raise TypeError(
"Expected all operators to have the same dtype. Found %s"
% " ".join(name_type))
# Auto-set and check hints.
if all(operator.is_non_singular for operator in operators):
if is_non_singular is False:
raise ValueError(
"The composition of non-singular operators is always non-singular.")
is_non_singular = True
# Initialization.
graph_parents = []
for operator in operators:
graph_parents.extend(operator.graph_parents)
if name is None:
name = "_o_".join(operator.name for operator in operators)
with ops.name_scope(name, values=graph_parents):
super(LinearOperatorComposition, self).__init__(
dtype=dtype,
graph_parents=graph_parents,
is_non_singular=is_non_singular,
is_self_adjoint=is_self_adjoint,
is_positive_definite=is_positive_definite,
is_square=is_square,
name=name)
@property
def operators(self):
return self._operators
def _shape(self):
# Get final matrix shape.
domain_dimension = self.operators[0].domain_dimension
for operator in self.operators[1:]:
domain_dimension.assert_is_compatible_with(operator.range_dimension)
domain_dimension = operator.domain_dimension
matrix_shape = tensor_shape.TensorShape(
[self.operators[0].range_dimension,
self.operators[-1].domain_dimension])
# Get broadcast batch shape.
# broadcast_shape checks for compatibility.
batch_shape = self.operators[0].batch_shape
for operator in self.operators[1:]:
batch_shape = common_shapes.broadcast_shape(
batch_shape, operator.batch_shape)
return batch_shape.concatenate(matrix_shape)
def _shape_tensor(self):
# Avoid messy broadcasting if possible.
if self.shape.is_fully_defined():
return ops.convert_to_tensor(
self.shape.as_list(), dtype=dtypes.int32, name="shape")
# Don't check the matrix dimensions. That would add unnecessary Asserts to
# the graph. Things will fail at runtime naturally if shapes are
# incompatible.
matrix_shape = array_ops.stack([
self.operators[0].range_dimension_tensor(),
self.operators[-1].domain_dimension_tensor()
])
# Dummy Tensor of zeros. Will never be materialized.
zeros = array_ops.zeros(shape=self.operators[0].batch_shape_tensor())
for operator in self.operators[1:]:
zeros += array_ops.zeros(shape=operator.batch_shape_tensor())
batch_shape = array_ops.shape(zeros)
return array_ops.concat((batch_shape, matrix_shape), 0)
def _matmul(self, x, adjoint=False, adjoint_arg=False):
# If self.operators = [A, B], and not adjoint, then
# matmul_order_list = [B, A].
# As a result, we return A.matmul(B.matmul(x))
if adjoint:
matmul_order_list = self.operators
else:
matmul_order_list = list(reversed(self.operators))
result = matmul_order_list[0].matmul(
x, adjoint=adjoint, adjoint_arg=adjoint_arg)
for operator in matmul_order_list[1:]:
result = operator.matmul(result, adjoint=adjoint)
return result
def _determinant(self):
result = self.operators[0].determinant()
for operator in self.operators[1:]:
result *= operator.determinant()
return result
def _log_abs_determinant(self):
result = self.operators[0].log_abs_determinant()
for operator in self.operators[1:]:
result += operator.log_abs_determinant()
return result
def _solve(self, rhs, adjoint=False, adjoint_arg=False):
# TODO(langmore) Implement solve using solve_ls if some intermediate
# operator maps to a high dimensional space.
# In that case, an exact solve may still be possible.
# If self.operators = [A, B], and not adjoint, then
# solve_order_list = [A, B].
# As a result, we return B.solve(A.solve(x))
if adjoint:
solve_order_list = list(reversed(self.operators))
else:
solve_order_list = self.operators
solution = solve_order_list[0].solve(
rhs, adjoint=adjoint, adjoint_arg=adjoint_arg)
for operator in solve_order_list[1:]:
solution = operator.solve(solution, adjoint=adjoint)
return solution
def _add_to_tensor(self, x):
return self.to_dense() + x
```
|
```clojure
(ns status-im.common.validation.general
(:require
[status-im.constants :as constants]
[utils.emojilib :as emoji]))
(defn valid-public-key?
[s]
(and (string? s)
(not-empty s)
(boolean (re-matches constants/regx-public-key s))))
(defn valid-compressed-key?
[s]
(and (string? s)
(not-empty s)
(boolean (re-matches constants/regx-compressed-key s))))
(defn has-emojis? [s] (boolean (re-find emoji/emoji-regex s)))
(def no-special-chars-regex #"^[a-zA-Z0-9\-_ ]+$")
(defn has-special-characters?
[s]
(and (not (= s ""))
(not (re-find no-special-chars-regex s))))
```
|
```go
// Code generated by smithy-go-codegen DO NOT EDIT.
package ec2
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/service/ec2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Assigns private IPv4 addresses to a private NAT gateway. For more information,
// see [Work with NAT gateways]in the Amazon VPC User Guide.
//
// [Work with NAT gateways]: path_to_url#nat-gateway-working-with
func (c *Client) AssignPrivateNatGatewayAddress(ctx context.Context, params *AssignPrivateNatGatewayAddressInput, optFns ...func(*Options)) (*AssignPrivateNatGatewayAddressOutput, error) {
if params == nil {
params = &AssignPrivateNatGatewayAddressInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AssignPrivateNatGatewayAddress", params, optFns, c.addOperationAssignPrivateNatGatewayAddressMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AssignPrivateNatGatewayAddressOutput)
out.ResultMetadata = metadata
return out, nil
}
type AssignPrivateNatGatewayAddressInput struct {
// The ID of the NAT gateway.
//
// This member is required.
NatGatewayId *string
// Checks whether you have the required permissions for the action, without
// actually making the request, and provides an error response. If you have the
// required permissions, the error response is DryRunOperation . Otherwise, it is
// UnauthorizedOperation .
DryRun *bool
// The number of private IP addresses to assign to the NAT gateway. You can't
// specify this parameter when also specifying private IP addresses.
PrivateIpAddressCount *int32
// The private IPv4 addresses you want to assign to the private NAT gateway.
PrivateIpAddresses []string
noSmithyDocumentSerde
}
type AssignPrivateNatGatewayAddressOutput struct {
// NAT gateway IP addresses.
NatGatewayAddresses []types.NatGatewayAddress
// The ID of the NAT gateway.
NatGatewayId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAssignPrivateNatGatewayAddressMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsEc2query_serializeOpAssignPrivateNatGatewayAddress{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsEc2query_deserializeOpAssignPrivateNatGatewayAddress{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "AssignPrivateNatGatewayAddress"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = addClientRequestID(stack); err != nil {
return err
}
if err = addComputeContentLength(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = addComputePayloadSHA256(stack); err != nil {
return err
}
if err = addRetry(stack, options); err != nil {
return err
}
if err = addRawResponseToMetadata(stack); err != nil {
return err
}
if err = addRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addTimeOffsetBuild(stack, c); err != nil {
return err
}
if err = addUserAgentRetryMode(stack, options); err != nil {
return err
}
if err = addOpAssignPrivateNatGatewayAddressValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssignPrivateNatGatewayAddress(options.Region), middleware.Before); err != nil {
return err
}
if err = addRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opAssignPrivateNatGatewayAddress(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "AssignPrivateNatGatewayAddress",
}
}
```
|
Fionbarr Farrell (born 3 March 1945) is an Irish épée, foil and sabre fencer. He competed in five events at the 1968 Summer Olympics.
References
External links
1945 births
Living people
Irish male épée fencers
Irish male foil fencers
Irish male sabre fencers
Olympic fencers for Ireland
Fencers at the 1968 Summer Olympics
|
Monticalia myrsinites is a species of flowering plant in the family Asteraceae. It is found only in Ecuador. Its natural habitats are subtropical or tropical moist montane forests and subtropical or tropical high-altitude shrubland. It is threatened by habitat loss.
References
myrsinites
Flora of Ecuador
Least concern plants
Taxonomy articles created by Polbot
Taxobox binomials not recognized by IUCN
|
```jsx
import React from 'react';
import PropTypes from 'prop-types';
import { CardBody } from 'reactstrap';
const CardGroup = ({ children, ...props }) => {
return <CardBody {...props}>{children}</CardBody>;
};
CardGroup.propTypes = {
children: PropTypes.node,
};
export default CardGroup;
```
|
Atractus torquatus, the neckband ground snake, is a species of snake in the family Colubridae. The species can be found in Colombia, Bolivia, Brazil, Peru, Venezuela, French Guiana, Guyana, and Ecuador.
References
Atractus
Reptiles of Colombia
Snakes of South America
Reptiles described in 1854
Taxa named by André Marie Constant Duméril
Taxa named by Gabriel Bibron
Taxa named by Auguste Duméril
|
Wang Xiangxi (; born August 1962) is a Chinese business executive and politician, currently serving as Minister of Emergency Management since July 2022.
He was a delegate to the 11th National People's Congress.
Early life and education
Wang was born in Mianyang County (now Xiantao), Hubei, in August 1962. After resuming the college entrance examination, in 1979, he enrolled at Jiaozuo Coal Mining School (now Henan Polytechnic University), majoring in coal mining engineering.
Career in Hubei
After graduating in 1983, he was assigned to the Songyi Mining Bureau, and eventually becoming first deputy director in March 1995. He joined the Chinese Communist Party (CCP) in April 1987. He successively served as deputy head of the Hubei Provincial Coal Industry Department in June 1996, director of the Hubei Coal Industry Management Office in February 2002, deputy director of the Hubei Provincial Economic and Trade Commission in August 2000, and director of the Hubei Provincial Quality and Technical Supervision Bureau in April 2003. In June 2006, he was named acting mayor of Jingzhou, confirmed in March 2007. In May 2010, he was appointed party secretary of Suizhou, in addition to serving as chairperson of its People's Congress. In July 2012, he was made secretary-general of Hubei Provincial People's Government, concurrently serving as director of the General Office of Hubei Provincial People's Government. He was admitted to member of the Standing Committee of the CCP Hubei Provincial Committee, the province's top authority, in June 2017, and appointed secretary of the Political and Legal Affairs Commission of the Hubei Provincial Committee of the Chinese Communist Party.
Career in state enterprise
In March 2019, he was chosen as chairman and party branch secretary of the China Energy Investment, a state-owned mining and energy company administrated by the SASAC of the State Council of the People's Republic of China.
Career in central government
On 29 July 2022, he was promoted to become minister of emergency management, succeeding Huang Ming.
References
1962 births
Living people
People from Xiantao
Henan Polytechnic University alumni
People's Republic of China politicians from Hubei
Chinese Communist Party politicians from Hubei
Delegates to the 11th National People's Congress
|
The Dräxlmaier Group is a globally operating automotive supplier with its headquarters in the Lower Bavarian city of Vilsbiburg, Germany. Founded in 1958, the family-owned company specializes in the production of wiring harness systems, central electrical and electronic components, interiors, and low- and high-voltage battery systems for electric mobility for premium vehicles.
Management
Stefan Brandl and Jan Reblin are responsible for the management of the company. Stefan Brandl became the new Vice Chairman of the Dräxlmaier Group in June 2021. Fritz Draxlmaier, who has been CEO for many years, serves as Chairman of the Board since January 2019.
Financial Information
In 2022, the corporation group achieved a revenue of EUR 5.1 billion and had around 74,000 employees. In terms of annual revenue, in 2022 the company ranked 64th among the 100 largest automotive suppliers in the world. The company's customers include Audi, BMW, Jaguar, Land Rover, Mercedes-Benz, MINI, Porsche, Tesla, and Volkswagen.
Source: Die WeltBundesanzeigerKonzernabschluss zum Geschäftsjahr vom 01.01.2018 bis zum 31.12.2018 [Annual accounts report for the period January 2018 till December 2018](in German), published in Bundesanzeiger on 10 January 2020.Konzernabschluss zum Geschäftsjahr vom 01.01.2014 bis zum 31.12.2014 [Annual accounts report for the period January 2014 till December 2014](in German), published in Bundesanzeiger on 11 February 2016.Konzernabschluss zum Geschäftsjahr vom 01.01.2010 bis zum 31.12.2010 [Annual accounts report for the period January 2010 till December 2010](in German), published in Bundesanzeiger on 9 February 2012.
Products
The Dräxlmaier Group supplies the international automotive industry. As an automotive supplier, the group has diversified into manufacturing of wiring harness systems, central electrical and electronic components, interior systems, as well as low- and high-voltage battery system for electric mobility. Product realisations were amongst others the interiors of the Maybach sedan and the Porsche Panamera, as well as the first door panel with visible natural fibre in the BMW i3. Further, Dräxlmaier is considered the inventor of the customised wiring harness.
Electrical systems
The company produces all elements of a wiring harness system, such as high-voltage and battery wiring harnesses, independent wiring harnesses, data wires and engine wiring harnesses. The Dräxlmaier Group produces components, systems and packages in digital electronics for interiors and vehicle electrical systems, high-voltage energy storage and electromobility.
Component systems
Dräxlmaier produces high-voltage and battery wiring, stand-alone wiring harnesses, data cables, and motor wiring harnesses. In addition, the company manufactures sensors and switches as well as high-voltage power distributors and fuse boxes.
Interior systems
Dräxlmaier manufactures instrument panels, centre consoles and door panels for premium automobiles. The automotive supplier also produces complete door and cockpit modules that are adapted to the special equipment of the respective vehicle through system integration. The company also creates RGB ambient lighting.
Battery systems
The product portfolio for battery systems includes electric high-voltage and low-voltage battery systems on a lithium-ion basis from 12 volt to 900 volt and HV components for an on-board voltage greater than 60 volt as well as high-voltage switch boxes.
History
1958–1967
In May 1958, Lisa and Fritz Dräxlmaier Sr. entered the growing automotive market. The first order placed with the Lower Bavarian company was the production of 50,000 wiring harnesses for the Goggomobil by Hans Glas GmbH in Dingolfing/Germany. Soon after, a second product division was established. Dräxlmaier now supplied the entire vehicle equipment (including instrument panels, door panels, seat coverings and rear shelves) for the compact car, which was built until 1969.
Dräxlmaier installed its first systems for welding door panels and forming thermoplastic sheets for the production of instrument panels in 1960. To accommodate the new equipment, the company's first own factory building was built in 1964.
In 1966, BMW became a new customer.
1968–1977
In 1968, the growing number of orders prompted Dräxlmaier to expand its Vilsbiburg site. As part of the expansion and renovation, the company set up its own mould and tool production, and installed its first computer system. In the same year, construction began on a new production and administration building. Audi and Volkswagen were supplied with products made by the Dräxlmaier Group starting in 1969 and 1971, respectively.
With a production site in Tunisia, international expansion began in 1974. In the following years, numerous other locations abroad were opened, including a production plant for wiring harnesses and interior components in Canada (1976).
1978–1987
Within 20 years, the business premises of the family-owned company steadily expanded, and the number of employees rose continuously during this time, with Dräxlmaier employing almost 2000 people in the course of the 1980s. The worldwide production network also expanded. A production site was established in Braunau am Inn, Austria (1978). Four more foreign subsidiaries followed.
In 1982, the company produced components for Mercedes-Benz for the first time. In 1983, Dräxlmaier used a mainframe computer for the first time and converted 100 workstations to electronic data processing. With the construction of the automated high-bay warehouse and the small-parts picking warehouse in 1987, the foundation for supply chain management was created. Since then, the material flow and all essential JIT/JIS processes have been controlled from here.
1988–1997
In 1993, Dräxlmaier opened production sites in the Czechia and Romania. With the order to develop, manufacture and supply the complete cockpit for the Mercedes-Benz CLK, the company took the step to becoming a system supplier for interiors in 1994. Two years later, in 1996, the production network was expanded with the establishment of new plants in America and Mexico.
In 1997, the Dräxlmaier Group of Companies was renamed Dräxlmaier Group. In the same year, the company was appointed to install the first "Functionally Integrated System" (FIS) in the BMW 7 Series. This resulted in the development of the first interior module to integrate all electrical and electronic functions included in a car door into one comprehensive system.
In November the same year, Dräxlmaier bought the subsidiary Holzindustrie Bruchsal GmbH from the then Daimler-Benz AG.
1998-2007
In 1998, the company moved into the new Dräxlmaier Technology Centre in Vilsbiburg. The next year, the Dräxlmaier Group produced a full-leather interior as the first system supplier for the Mercedes-Benz CL Coupe.
This was followed by the production of the complete interior of the BMW Z8. For both models, Dräxlmaier developed and supplied the wiring system.
In 2002, Dräxlmaier developed, produced and delivered the complete wiring system and interior for the Maybach luxury sedan. In addition to a second location in Landau an der Isar/Germany, in 2003 a new plant was built in Shenyang/China. Since then, Porsche, Jaguar and Cadillac have become part of the company's customer base.
In 2005-2007, further sites were opened in South Africa (2005); in 2006 in Thailand, Spain and Mexico; and in 2007 in Balti, Moldova, where Dräxlmaier built a completely new factory employing 2000 people.
2008–2017
The Dräxlmaier Group introduced a natural fibre composite material for vehicle interiors in 2008. The door panel developed for the BMW 7 Series is made of biocomposite material. The same year another Eastern European location followed with the opening of a production plant in Serbia, initially employing 800 workers on three assembly lines.
In 2009, the group started building prototypes for electromobility and developed customised battery systems and components, for example for the complete interior and the electrical system of the Porsche Panamera, which was launched on the market in the same year.
In 2011, Dräxlmaier developed the world's first door panel with visible natural fibre. This was first installed in the all-electric BMW i3 in 2013. The company expanded its existing production facilities in Shenyang in 2012 and built a fully integrated production plant in Kavadarci/Macedonia. In 2013, another Dräxlmaier Group site opened in Leipzig/Germany. In the same year, a new business segment was opened with Dräxlmaier Aviation GmbH. Until 2017, the company developed and produced interiors for private and business aircraft.
Another customer, Tesla Motors, was acquired in 2014. In the same year, the company's logistics network was expanded with the facilities in Zwickau/Germany. In 2015, QESTRONIC Advanced Technologies GmbH from Geisenhausen/Germany, was integrated into the Dräxlmaier Group. One year later a new production site was opened for interior components in Langfang/China.
In cooperation with the Technical University of Munich (Germany), a research and development location was established on the Garching campus in 2017. A new production site for interior components was opened in Livermore, USA.
2018–present
In 2018, the Dräxlmaier Campus was built on the grounds of the GALILEO centre of the Technical University of Munich in Garching. There, Dräxlmaier developers and researching professors of the TUM work on future topics of the automotive industry. In 2019, the company built its own plant with a development department in Sachsenheim near Stuttgart for the production of 800-volt automotive batteries. One year later another plant near Leipzig followed.
On April 1, 2020, Franz Haslinger and Martin Gall took on the function of CEOs of the Dräxlmaier Group. Since August 2021, Stefan Brandl and Haslinger have been responsible for the management. Long-term CEO Fritz Dräxlmaier remains associated with the company as a representative of the shareholders and continues to exercise his function as chairman of the board.
In 2021, the Dräxlmaier Group was included in the list of the World's Best Employers by Forbes. In 2022, the DRÄXLMAIER Group was again awarded the title "World's Best Employer" by Forbes. In 2023, the company received the Top Employer Germany award. In the same year, the DRÄXLMAIER Group celebrated its 65th anniversary.
Bibliography
Angstl, Martin; Baur, Yvonne; Berk, Fabian; Keil; Thomas; Pflügler, Wolfgang: Nachhaltig erfolgreich – Green Logistics made by Dräxlmaier, in: Praxishandbuch Grüne Automobillogistik. Wiesbaden: Springen Gabler 2016, ISBN 978-3-658-04808-2.
Brake, Ludger: Driver: Integrierter Steuerungs- und Reportingansatz der Dräxlmaier Group, in: Moderne Controllingkonzepte - Zukünftige Anforderungen erkennen und integrieren. Freiburg: Haufe 2015, ISBN 978-3-648-07216-5.
Nickel, Tobias: Dräxlmeier - we create character. Vilsbiburg: E-Motion Verlag 2019, .
References
Auto parts suppliers of Germany
Manufacturing companies established in 1958
German brands
1958 establishments in West Germany
|
```c
/* $OpenBSD: rec_delete.c,v 1.10 2005/08/05 13:03:00 espie Exp $ */
/*-
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Mike Olson.
*
* 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 the University 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 REGENTS 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 REGENTS 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.
*/
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <db.h>
#include "recno.h"
static int rec_rdelete(BTREE *, recno_t);
/*
* __REC_DELETE -- Delete the item(s) referenced by a key.
*
* Parameters:
* dbp: pointer to access method
* key: key to delete
* flags: R_CURSOR if deleting what the cursor references
*
* Returns:
* RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key not found.
*/
int
__rec_delete(const DB *dbp, const DBT *key, u_int flags)
{
BTREE *t;
recno_t nrec;
int status;
t = dbp->internal;
/* Toss any page pinned across calls. */
if (t->bt_pinned != NULL) {
mpool_put(t->bt_mp, t->bt_pinned, 0);
t->bt_pinned = NULL;
}
switch(flags) {
case 0:
if ((nrec = *(recno_t *)key->data) == 0)
goto einval;
if (nrec > t->bt_nrecs)
return (RET_SPECIAL);
--nrec;
status = rec_rdelete(t, nrec);
break;
case R_CURSOR:
if (!F_ISSET(&t->bt_cursor, CURS_INIT))
goto einval;
if (t->bt_nrecs == 0)
return (RET_SPECIAL);
status = rec_rdelete(t, t->bt_cursor.rcursor - 1);
if (status == RET_SUCCESS)
--t->bt_cursor.rcursor;
break;
default:
einval: errno = EINVAL;
return (RET_ERROR);
}
if (status == RET_SUCCESS)
F_SET(t, B_MODIFIED | R_MODIFIED);
return (status);
}
/*
* REC_RDELETE -- Delete the data matching the specified key.
*
* Parameters:
* tree: tree
* nrec: record to delete
*
* Returns:
* RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key not found.
*/
static int
rec_rdelete(BTREE *t, recno_t nrec)
{
EPG *e;
PAGE *h;
int status;
/* Find the record; __rec_search pins the page. */
if ((e = __rec_search(t, nrec, SDELETE)) == NULL)
return (RET_ERROR);
/* Delete the record. */
h = e->page;
status = __rec_dleaf(t, h, e->index);
if (status != RET_SUCCESS) {
mpool_put(t->bt_mp, h, 0);
return (status);
}
mpool_put(t->bt_mp, h, MPOOL_DIRTY);
return (RET_SUCCESS);
}
/*
* __REC_DLEAF -- Delete a single record from a recno leaf page.
*
* Parameters:
* t: tree
* idx: index on current page to delete
*
* Returns:
* RET_SUCCESS, RET_ERROR.
*/
int
__rec_dleaf(BTREE *t, PAGE *h, u_int32_t idx)
{
RLEAF *rl;
indx_t *ip, cnt, offset;
u_int32_t nbytes;
char *from;
void *to;
/*
* Delete a record from a recno leaf page. Internal records are never
* deleted from internal pages, regardless of the records that caused
* them to be added being deleted. Pages made empty by deletion are
* not reclaimed. They are, however, made available for reuse.
*
* Pack the remaining entries at the end of the page, shift the indices
* down, overwriting the deleted record and its index. If the record
* uses overflow pages, make them available for reuse.
*/
to = rl = GETRLEAF(h, idx);
if (rl->flags & P_BIGDATA && __ovfl_delete(t, rl->bytes) == RET_ERROR)
return (RET_ERROR);
nbytes = NRLEAF(rl);
/*
* Compress the key/data pairs. Compress and adjust the [BR]LEAF
* offsets. Reset the headers.
*/
from = (char *)h + h->upper;
memmove(from + nbytes, from, (char *)to - from);
h->upper += nbytes;
offset = h->linp[idx];
for (cnt = &h->linp[idx] - (ip = &h->linp[0]); cnt--; ++ip)
if (ip[0] < offset)
ip[0] += nbytes;
for (cnt = &h->linp[NEXTINDEX(h)] - ip; --cnt; ++ip)
ip[0] = ip[1] < offset ? ip[1] + nbytes : ip[1];
h->lower -= sizeof(indx_t);
--t->bt_nrecs;
return (RET_SUCCESS);
}
```
|
Gilbert d'Oignies (ca. 1520–1574) was a bishop of Tournai in the Habsburg Netherlands.
Life
Gilbert was born in Lille or Tournai around 1520, the son of Jean d'Oignies and Marguerite de Launir. He was appointed to a canonry of Tournai Cathedral and became vicar general to Charles de Croÿ, in succession to whom he was appointed bishop of Tournai. He received episcopal consecration on 21 October 1565 in the church of Saint-Amand Abbey.
At the outbreak of the Iconoclastic Fury, particularly overwhelming in the Tournaisis, d'Oignies sought refuge in Lille, only returning to his see in January 1567. He established a second archdeacon in Tournai, so that the French-speaking and Dutch-speaking parts of his diocese would be separate archdeaconries, with the deaneries of Tournai, Lille and Seclin in one and those of Kortrijk and Helkijn in the other. On 25 August 1574 he died of plague while on a visit to Kortrijk. His body was returned to Tournai for burial.
References
Date of birth uncertain
1574 deaths
Bishops of Tournai
|
```yaml
apiVersion: v1
data:
kernel-monitor.json: |
{
"plugin": "kmsg",
"logPath": "/dev/kmsg",
"lookback": "5m",
"bufferSize": 10,
"source": "kernel-monitor",
"conditions": [
{
"type": "KernelDeadlock",
"reason": "KernelHasNoDeadlock",
"message": "kernel has no deadlock"
},
{
"type": "ReadonlyFilesystem",
"reason": "FilesystemIsNotReadOnly",
"message": "Filesystem is not read-only"
}
],
"rules": [
{
"type": "temporary",
"reason": "OOMKilling",
"pattern": "Kill process \\d+ (.+) score \\d+ or sacrifice child\\nKilled process \\d+ (.+) total-vm:\\d+kB, anon-rss:\\d+kB, file-rss:\\d+kB.*"
},
{
"type": "temporary",
"reason": "TaskHung",
"pattern": "task \\S+:\\w+ blocked for more than \\w+ seconds\\."
},
{
"type": "temporary",
"reason": "UnregisterNetDevice",
"pattern": "unregister_netdevice: waiting for \\w+ to become free. Usage count = \\d+"
},
{
"type": "temporary",
"reason": "KernelOops",
"pattern": "BUG: unable to handle kernel NULL pointer dereference at .*"
},
{
"type": "temporary",
"reason": "KernelOops",
"pattern": "divide error: 0000 \\[#\\d+\\] SMP"
},
{
"type": "temporary",
"reason": "MemoryReadError",
"pattern": "CE memory read error .*"
},
{
"type": "permanent",
"condition": "KernelDeadlock",
"reason": "DockerHung",
"pattern": "task docker:\\w+ blocked for more than \\w+ seconds\\."
},
{
"type": "permanent",
"condition": "ReadonlyFilesystem",
"reason": "FilesystemIsReadOnly",
"pattern": "Remounting filesystem read-only"
}
]
}
docker-monitor.json: |
{
"plugin": "journald",
"pluginConfig": {
"source": "dockerd"
},
"logPath": "/var/log/journal",
"lookback": "5m",
"bufferSize": 10,
"source": "docker-monitor",
"conditions": [],
"rules": [
{
"type": "temporary",
"reason": "CorruptDockerImage",
"pattern": "Error trying v2 registry: failed to register layer: rename /var/lib/docker/image/(.+) /var/lib/docker/image/(.+): directory not empty.*"
}
]
}
kind: ConfigMap
metadata:
name: node-problem-detector-config
namespace: kube-system
```
|
The Wilson Avenue Line is a public transit line in Brooklyn, New York City, running along Wilson Avenue and Rockaway Avenue between Williamsburg and Canarsie. Originally a streetcar line, it is now the B60 bus route, operated by MTA New York City Bus.
Route description
The B60 bus route starts at Williamsburg Bridge Plaza near the Marcy Avenue station. After the subway station, buses head north and use a number of streets through the neighborhood, eventually reaching the Morgan Avenue station on the BMT Canarsie Line. Buses then reach Wilson Avenue and run along the street, parallel to the Canarsie Line until it reaches Decatur and Cooper Streets, near the Wilson Avenue station. Then the route heads south down Decatur and Cooper parallel to the B20 bus, until it reaches Broadway, where the route now heads down Rockaway Avenue. South of Brookdale University Hospital and Medical Center, the B60 enters Canarsie and turns onto Rockaway Parkway. At Rockaway Parkway and Glenwood Road is the Rockaway Parkway terminus of the Canarsie Line and a transfer point to several routes, including the B6, B17, B42 and B82. However, like the B17, the B60 does not have its own dedicated loop and northbound buses stop in front of the station entrance, while southbound service stops on Glenwood Rd at the B6 bus stand. At this point, the B60 continues east along the B6 and B82 routes until East 108th Street, where southbound buses loop around the Breukelen Houses, and ends at Williams Avenue and Flatlands Avenue near the Breukelen Park. Northbound service follows the B82 route to Rockaway Parkway and resumes the regular route.
History
The line was built after 1897 by the Nassau Electric Railroad to gain access to Williamsburg and the Williamsburg Bridge into Manhattan. The line began at Canarsie-Rockaway Parkway on the Canarsie Line and ran north and west along Rockaway Parkway, Rockaway Avenue, Cooper Street, Wilson Avenue, Morgan Avenue, Johnson Avenue, and Broadway to the bridge. Later, eastbound traffic from the bridge was rerouted to use the Bushwick Avenue Line (South 4th Street, Meserole Street, and Bushwick Avenue) to the crossing of Bushwick and Johnson Avenues, and westbound Bushwick Avenue cars were moved to the Wilson Avenue Line. Buses were substituted for streetcars on May 27, 1951.
On December 1, 2022, the MTA released a draft redesign of the Brooklyn bus network. As part of the redesign, the B60 would be split in half at Fulton Street. The southern half would keep the B60 designation, and the northern half would take the new B66 designation. At Fulton Street, both routes would run east along Fulton Street to terminate at Broadway Junction. The B60 would use Flatlands Avenue in both directions in Canarsie. Closely spaced stops would also be eliminated.
As part of a pilot program by the MTA to make five bus routes free (one in each borough), the B60 was selected alongside the Bx18, M116, Q4 and S46/96 to become fare-free in July 2023. The pilot program would last six to twelve months and buses would display a "Fare Free" sign, similar to the one used on the Q70. The pilot will run from September 24, 2023 until at least March 30, 2024.
References
External links
Streetcar lines in Brooklyn
B060
B060
|
```objective-c
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_LAYOUT_DESCRIPTOR_INL_H_
#define V8_LAYOUT_DESCRIPTOR_INL_H_
#include "src/layout-descriptor.h"
#include "src/objects-inl.h"
#include "src/objects/descriptor-array.h"
namespace v8 {
namespace internal {
LayoutDescriptor* LayoutDescriptor::FromSmi(Smi* smi) {
return LayoutDescriptor::cast(smi);
}
Handle<LayoutDescriptor> LayoutDescriptor::New(Isolate* isolate, int length) {
if (length <= kSmiValueSize) {
// The whole bit vector fits into a smi.
return handle(LayoutDescriptor::FromSmi(Smi::kZero), isolate);
}
int backing_store_length = GetSlowModeBackingStoreLength(length);
Handle<LayoutDescriptor> result = Handle<LayoutDescriptor>::cast(
isolate->factory()->NewByteArray(backing_store_length, TENURED));
memset(reinterpret_cast<void*>(result->GetDataStartAddress()), 0,
result->DataSize());
return result;
}
bool LayoutDescriptor::InobjectUnboxedField(int inobject_properties,
PropertyDetails details) {
if (details.location() != kField || !details.representation().IsDouble()) {
return false;
}
// We care only about in-object properties.
return details.field_index() < inobject_properties;
}
LayoutDescriptor* LayoutDescriptor::FastPointerLayout() {
return LayoutDescriptor::FromSmi(Smi::kZero);
}
bool LayoutDescriptor::GetIndexes(int field_index, int* layout_word_index,
int* layout_bit_index) {
if (static_cast<unsigned>(field_index) >= static_cast<unsigned>(capacity())) {
return false;
}
*layout_word_index = field_index / kBitsPerLayoutWord;
CHECK((!IsSmi() && (*layout_word_index < length())) ||
(IsSmi() && (*layout_word_index < 1)));
*layout_bit_index = field_index % kBitsPerLayoutWord;
return true;
}
LayoutDescriptor* LayoutDescriptor::SetRawData(int field_index) {
return SetTagged(field_index, false);
}
LayoutDescriptor* LayoutDescriptor::SetTagged(int field_index, bool tagged) {
int layout_word_index = 0;
int layout_bit_index = 0;
CHECK(GetIndexes(field_index, &layout_word_index, &layout_bit_index));
uint32_t layout_mask = static_cast<uint32_t>(1) << layout_bit_index;
if (IsSlowLayout()) {
uint32_t value = get_layout_word(layout_word_index);
if (tagged) {
value &= ~layout_mask;
} else {
value |= layout_mask;
}
set_layout_word(layout_word_index, value);
return this;
} else {
uint32_t value = static_cast<uint32_t>(Smi::ToInt(this));
if (tagged) {
value &= ~layout_mask;
} else {
value |= layout_mask;
}
return LayoutDescriptor::FromSmi(Smi::FromInt(static_cast<int>(value)));
}
}
bool LayoutDescriptor::IsTagged(int field_index) {
if (IsFastPointerLayout()) return true;
int layout_word_index;
int layout_bit_index;
if (!GetIndexes(field_index, &layout_word_index, &layout_bit_index)) {
// All bits after Out of bounds queries
return true;
}
uint32_t layout_mask = static_cast<uint32_t>(1) << layout_bit_index;
if (IsSlowLayout()) {
uint32_t value = get_layout_word(layout_word_index);
return (value & layout_mask) == 0;
} else {
uint32_t value = static_cast<uint32_t>(Smi::ToInt(this));
return (value & layout_mask) == 0;
}
}
bool LayoutDescriptor::IsFastPointerLayout() {
return this == FastPointerLayout();
}
bool LayoutDescriptor::IsFastPointerLayout(Object* layout_descriptor) {
return layout_descriptor == FastPointerLayout();
}
bool LayoutDescriptor::IsSlowLayout() { return !IsSmi(); }
int LayoutDescriptor::capacity() {
return IsSlowLayout() ? (length() * kBitsPerByte) : kSmiValueSize;
}
LayoutDescriptor* LayoutDescriptor::cast_gc_safe(Object* object) {
// The map word of the object can be a forwarding pointer during
// object evacuation phase of GC. Since the layout descriptor methods
// for checking whether a field is tagged or not do not depend on the
// object map, it should be safe.
return reinterpret_cast<LayoutDescriptor*>(object);
}
int LayoutDescriptor::GetSlowModeBackingStoreLength(int length) {
DCHECK_LT(0, length);
// We allocate kPointerSize rounded blocks of memory anyway so we increase
// the length of allocated array to utilize that "lost" space which could
// also help to avoid layout descriptor reallocations.
return RoundUp(length, kBitsPerByte * kPointerSize) / kBitsPerByte;
}
int LayoutDescriptor::CalculateCapacity(Map* map, DescriptorArray* descriptors,
int num_descriptors) {
int inobject_properties = map->GetInObjectProperties();
if (inobject_properties == 0) return 0;
DCHECK_LE(num_descriptors, descriptors->number_of_descriptors());
int layout_descriptor_length;
const int kMaxWordsPerField = kDoubleSize / kPointerSize;
if (num_descriptors <= kSmiValueSize / kMaxWordsPerField) {
// Even in the "worst" case (all fields are doubles) it would fit into
// a Smi, so no need to calculate length.
layout_descriptor_length = kSmiValueSize;
} else {
layout_descriptor_length = 0;
for (int i = 0; i < num_descriptors; i++) {
PropertyDetails details = descriptors->GetDetails(i);
if (!InobjectUnboxedField(inobject_properties, details)) continue;
int field_index = details.field_index();
int field_width_in_words = details.field_width_in_words();
layout_descriptor_length =
Max(layout_descriptor_length, field_index + field_width_in_words);
}
}
layout_descriptor_length = Min(layout_descriptor_length, inobject_properties);
return layout_descriptor_length;
}
LayoutDescriptor* LayoutDescriptor::Initialize(
LayoutDescriptor* layout_descriptor, Map* map, DescriptorArray* descriptors,
int num_descriptors) {
DisallowHeapAllocation no_allocation;
int inobject_properties = map->GetInObjectProperties();
for (int i = 0; i < num_descriptors; i++) {
PropertyDetails details = descriptors->GetDetails(i);
if (!InobjectUnboxedField(inobject_properties, details)) {
DCHECK(details.location() != kField ||
layout_descriptor->IsTagged(details.field_index()));
continue;
}
int field_index = details.field_index();
layout_descriptor = layout_descriptor->SetRawData(field_index);
if (details.field_width_in_words() > 1) {
layout_descriptor = layout_descriptor->SetRawData(field_index + 1);
}
}
return layout_descriptor;
}
// LayoutDescriptorHelper is a helper class for querying whether inobject
// property at offset is Double or not.
LayoutDescriptorHelper::LayoutDescriptorHelper(Map* map)
: all_fields_tagged_(true),
header_size_(0),
layout_descriptor_(LayoutDescriptor::FastPointerLayout()) {
if (!FLAG_unbox_double_fields) return;
layout_descriptor_ = map->layout_descriptor_gc_safe();
if (layout_descriptor_->IsFastPointerLayout()) {
return;
}
header_size_ = map->GetInObjectPropertiesStartInWords() * kPointerSize;
DCHECK_GE(header_size_, 0);
all_fields_tagged_ = false;
}
bool LayoutDescriptorHelper::IsTagged(int offset_in_bytes) {
DCHECK(IsAligned(offset_in_bytes, kPointerSize));
if (all_fields_tagged_) return true;
// Object headers do not contain non-tagged fields.
if (offset_in_bytes < header_size_) return true;
int field_index = (offset_in_bytes - header_size_) / kPointerSize;
return layout_descriptor_->IsTagged(field_index);
}
} // namespace internal
} // namespace v8
#endif // V8_LAYOUT_DESCRIPTOR_INL_H_
```
|
```html
<HTML>
<HEAD><TITLE>-</TITLE></HEAD>
<FRAMESET COLS="150,*">
<FRAMESET ROWS="50%,50%">
<FRAME SRC="namespaces.html" NAME="namespaces">
<FRAME SRC="GNU_Gettext.html" NAME="members">
</FRAMESET>
<FRAME SRC="begin.html" NAME="contents">
</FRAMESET>
</HTML>
```
|
Strengthening Participatory Organization is the largest rights-based national support organization in Pakistan working since 1994 to strengthen and support community organizations and public interest institutions for promotion of democratic governance, social justice, peace and social harmony. SPO engages civil society networks, faith-based organisations and groups representing a wide range of stakeholders.
SPO focuses on capacity building of community institutions and nurtures civil society networks at the grassroots. SPO has so far worked in 77 districts out of 110 across four provinces and trained more than 3,000 community-based and local government institutions, strengthened 56 rights-based advocacy networks and undertook special projects for girls, education and humanitarian relief in case of natural disasters. All special projects are run with the help of community partners.
SPO envisions a democratic, socially just and tolerant society guided by participatory principles, which realizes the full potential of its people and their aspirations for sustainable and self-reliant development.
The mission is to strengthen and support community organisations and public interest institutions of Pakistan for the benefit of poor and disadvantaged sections of society for sustainable development through a participatory approach.
History
Strengthening Participatory Organization began its life in the early 1990s as the Small Projects Office (SPO) of the Canadian International Development Agency (CIDA) programme in Pakistan. On January 15, 1994, the Small Projects Office was transformed into an indigenous NGO. The decade since that inception has seen many more transformations and developments.
From its humble beginning as a small and very new NGO in 1994, Strengthening Participatory Organization has grown to become one of the leading NGOs in Pakistan - in terms of its size and resources, the scope of its activities, its reach across the country, and the impact of its work.
SPO did not start off as strengthening in participatory organization. Its original role was limited and temporary:to function as a Small Project Office for the Social Sector Funds (SSF) Project of the Canadian International Development Agency (CIDA).
But in the eight years that follow the small project office acquired a life and niche of its own. But by end of this period it has transformed into an independent organization working for a different and deeper mandate than the one with which it had begun.
This chapter becomes SPO's eight years growth to maturity and transformation from a small, project support office to a prominent contributor to participatory development in Pakistan.
Aims and objectives
It is estimated that some 1,500,000 people have benefited directly through SPO's training programme and projects and another one million indirectly.
A few achievements of SPO's programme are listed below:
Empowering women
Increased number of women organisations have been strengthened, providing a platform to women to play an active role in integrating their own concerns in the overall planning process. The confidence of women has increased and their involvement in decision-making ensured. Women have been especially sensitised for good governance and provided political education so that they can play a role in the local government. Choti funding has also spurred economic activities that benefit female community members.
Promoting development
SPO's partner organisations demonstrated maturity in planning and undertaking development activities—over 300 CBOs and WOs designed development projects that addressed key needs of their communities. They were able to secure funds for these projects from SPO as well as other donors such as Trust for Voluntary Organisations (TVO), The Canada Fund and other bilateral donors. At least 30 percent of the beneficiaries of these projects hailed from the poorest segments of the target communities and no less than 30 percent were women. The POs also involved a large number of the intended beneficiaries in project needs, assessment, design and management. Environmental safeguards were built in.
Changing attitudes
Through SPO's interventions, an attitudinal change in society was observed where people demand that their basic needs are fulfilled and seen as their rights, rather than taking the fulfilment of such needs as a privilege. In order to strengthen advocacy for change, civil society organisations were linked with regional and sectoral networks to play a leading role in representing grass root communities. This further increased the participation of communities in decision-making.
Promoting policy debate
SPO has grown as an institution with the ability to develop linkages among grass root communities and policy-making institutions. Until now, SPO has engaged local communities to assist government in policy development processes including devolution of power plan, youth policy, education policy and repealing Hudood Ordinances. These networks gave their input at the policy level in provincial and national forums. Wide-ranging consultation processes were initiated by SPO across Pakistan. Representatives of government, NGOs, CBOs and the communities extensively attended consultative workshops.
Rights-based political education and supporting democracy
The POs played a vital role in order to provide women leadership in the first two phases of local bodies elections and the last two general elections. In order to ensure effective participation of women, the minimum female participation of 33% was achieved in Punjab through advocacy campaigns in collaboration with other agencies. SPO's local resource persons were also actively involved in 46 districts. 781 members of SPO partner organisations contested the elections, out of which, 536 were elected from all over the country. After reduction in seats more than 400 got elected in the second round. A larger number of activists participated in the process through campaigning, canvassing and bringing the development agenda to the fore. SPO can justifiably claim to have acted as a catalyst for smooth implementation of the new local government system.
SPO has established a mechanism through its local partner networks to collect feedback on government policies, review performance and propose alternative solutions. During the last year, SPO partner networks conducted research based studies in the areas of health and education.
Some interventions with political parties in 10 districts of all four provinces have provided an opportunity to establish a mechanism to communicate priorities and expectations of civil society to political leadership.
Reviving communities affected by natural disasters
SPO is very much rooted in the local communities in at least half of the districts of Pakistan. In any situation of emergency or disasters, it stands by these communities through developing and implementing relief and rehabilitation programme. During one of the most severe earthquakes of human history, which affected the lives of people in northern Pakistan, SPO was the only leading organisation, which utilized its full potential to mobilize resources in a very short time. The resources both cash and in kind were worth 40 million rupees. A number of small initiatives were undertaken in collaboration with other partners for communities in the areas of education and health. SPO has also provided massive support to flood affected communities in Turbat, Bolan, Gwadar, Naseerabad, Jaffarabad, Thatta, Badin, Swat and Rawalpindi (districts across four provinces). SPO was the first organisation to train the implementing partners of Earthquake Reconstruction and Rehabilitation Authority (ERRA), including the army, in community mobilisation and the only national organisation to work at the policy level with the newly formed National Disaster Management Authority (NDMA).
Programmes
Democratic Governance Programme
The Democratic Governance Programme emphasises on mainstreaming of marginalised communities in decision making processes by working towards the realisation of the basic human rights as described in the Universal Declaration of Human Rights (UDHR) and the Constitution of Pakistan. It ultimately leads to the next stage of claiming rights from policy and decision making institutions in a democratic manner. It is achieved through extensive political education through Civil Society Networks on regular basis. Enabling the people through education and training to participate fully in all forms of voluntary activities for social development is encouraged. Youth, the most vibrant section of the society is engaged and mainstreamed in social and political processes through this programme.
Social Justice Programme
The Social Justice Programme is a mean to establish and expedite the community-rooted mechanisms in order to secure the well being of people, irrespective of caste, creed, colour or sex, by improving their quality of life. The programme aims to support mechanisms largely in the public sector and those devised by the civil society in the areas of basic education, primary healthcare, livelihood support to women and relief and rehabilitation after natural disasters in areas where SPO works.
Peace and Social Harmony Programme
The Peace and Social Harmony Programme encourages civil society networks, faith-based organisations and groups, representing a wide range of stakeholders, to jointly participate in decision-making processes for the protection of basic rights regardless of religion, language, ethnicity and class differences. The programme is based on building social harmony among diversified groups to share and understand each other's point of view and respect differences. The major challenges to be dealt with include the rising sectarian differences and inter-provincial harmony. ‘Politics of Consent, is encouraged resulting in informed, thoroughly debated, and positive public and policy messages of awareness raising and advocacy.
Coverage
SPO is working in the following districts:
Balochistan (18 districts):
Awaran, Bolan, Chaghai, Gwadar, Jaffarabad, Kech, Lasbella, Loralai, Mastung, Naseerabad, Nushki, Khuzdar, Panjgur, Pishin, Quetta, Sibi, Washuk, Ziarat
NWFP (9 districts and FATA):
Charsadda, Chitral, Dir, Dera Ismail Khan, Malakand, Mardan, Peshawar, Swat, Shangla, FATA (Khyber, Orakzai and Mohmand Agencies)
Punjab (14 districts):
Bahawalpur, Bhakkar, Dera Ghazi Khan, Gujranwala, Khanewal, Khushab, Lahore, Layyah, Lodhran, Mianwali, Multan, Muzaffargarh, Sargodha, Vehari
Sindh (12 districts):
Badin, Hyderabad, Ghotki, Karachi, Matiari, Mirpurkhas, Nawabshah, Shikarpur, Tando Allahyar, Tando Muhammad Khan, Thatta, Umerkot
Offices
SPO manages and implements its programmes through nine permanent and three temporary project offices:
National Center (Islamabad)
Balochistan (Quetta and Turbat)
NWFP (Peshawar and Dera Ismail Khan)
Punjab (Lahore and Multan)
Sindh (Karachi and Hyderabad)
Project Offices in Azad Kashmir (Muzaffarabad, Bagh Neelum and in Sukkur Sindh)
References
External links
SPO Documentary - Hum Hongay Kamyab 1/3
SPO Documentary - Hum Hongay Kamyab 2/3
SPO Documentary - Hum Hongay Kamyab 3/3
Human rights organisations based in Pakistan
Non-profit organisations based in Pakistan
1994 establishments in Pakistan
Organizations established in 1994
|
Crawford is a small town in Lowndes County, Mississippi, United States. The population was 641 at the 2010 census.
History
During the 1840s, a Baptist minister named Peter Crawford lived in the area. When the town was platted in 1852, it was named Crawfordsville. This name was used until 1870, when it was shortened to Crawfordville. Finally in 1879 it was changed to Crawford.
The Mobile and Ohio Railroad came though Crawfordsville in 1857.
Geography
Crawford is located at (33.306205, -88.621933).
According to the United States Census Bureau, the town has a total area of , all land.
Demographics
As of the 2010 United States Census, there were 641 people in the town. 89.9% were African American, 8.0% White, 0.6% Native American and 1.6% of two or more races. 0.6% were Hispanic or Latino of any race.
As of the 2000 United States Census there were 655 people, 209 households, and 163 families in the town. The population density was . There were 251 housing units at an average density of . The racial makeup of the town was 93.13% African American, 5.95% White, 0.31% Native American, 0.15% from other races, and 0.46% from two or more races. Hispanic or Latino of any race were 0.61% of the population.
There were 309 households, out of which 45.0% had children under the age of 18 living with them, 31.6% were married couples living together, 42.1% had a female householder with no husband present, and 22.0% were non-families. 20.6% of all households were made up of individuals, and 7.7% had someone living alone who was 65 years of age or older. The average household size was 3.13 and the average family size was 3.67.
The town population contained 41.5% under the age of 18, 9.0% from 18 to 24, 25.6% from 25 to 44, 17.1% from 45 to 64, and 6.7% who were 65 years of age or older. The median age was 24 years. For every 100 females, there were 75.1 males. For every 100 females age 18 and over, there were 67.2 males.
The median income for a household in the town was $16,786, and the median income for a family was $16,058. Males had a median income of $24,107 versus $14,359 for females. The per capita income for the town was $7,123. About 45.5% of families and 45.7% of the population are below the poverty line, including 60.5% of those under age 18 and 35.3% of those age 65 or over.
Education
The Town of Crawford is served by the Lowndes County School District.
Notable people
Thomas Watt Gregory, US Attorney General from 1914 to 1919
Sam Hairston, former Negro league baseball and MLB player
Jerry Rice, NFL first ballot Hall of Fame wide receiver
Don "Cadillac Don" Sharp, rap/hip-hop artist
Clarence Weatherspoon, NBA player
Big Joe Williams, Mississippi Musicians Hall of Fame blues singer and guitarist; born in Crawford in 1903
George "Bloodchoke" Foster III, USAF MSgt Aircrew flight equipment specialist and quality assurance
References
See also
Crawford City Hall (contact information)
Hairston: History of Crawford, Lowndes County, Mississippi
Towns in Lowndes County, Mississippi
Towns in Mississippi
|
Brandon Graham (born 1976 in Oregon) is an American comic book creator.
Biography
Born in Oregon, Graham grew up in Seattle, Washington, where he was a graffiti artist. He wrote and illustrated comic books for Antarctic Press and Radio Comix, but got his start drawing pornographic comics such as Pillow Fight, Perverts of the Unknown and the initial issue of Multiple Warheads (Warheads would go on to become an ongoing, more mainstream comic published by Oni Press in 2007). In 1997, he moved to New York City where he found work with NBM Publishing and became a founding member of comics collective Meathaus. His book Escalator was published by Alternative Comics in January 2005, when he returned to Seattle. His book King City was published by Tokyopop in 2007 and was nominated for an Eisner Award. In May 2009 Graham announced that King City would continue publication at Image Comics and his Oni Press title Multiple Warheads would resume publication after a delay, this time in color.
At Image he led the revival of Prophet, a sci-fi reboot of Rob Liefeld's 1990s series, with a rotating roster of artists including Giannis Milonogiannis, Farel Dalrymple, and Simon Roy.
Bibliography
Early work
October Yen #1-3 (w/a, Antarctic Press, 1996)
A-Bomb vol. 2 #1: "Blueprints" (w/a, anthology, Anthill, 1999)
Meathaus #4-8 (w/a, anthology, Meathaus Press, 2001–2006)
Radio Comix:
Milk! #7: "Paris Paris" (w/a, anthology, 1998)
Universe So Big #1-2 (w/a, 1999)
Mangaphile (w/a, anthology):
"Gone Fishin" (in #13, 2001)
"True Crime" (in #14, 2001)
Sizzle (w/a, anthology, NBM Publishing):
"Perverts of the Unknown" (in #13-15, 2002) collected as Perverts of the Unknown (tpb, 64 pages, Eurotica, 2003, )
"Multiple Warheadz" (in #18, 2003) collected in Complete Multiple Warheads (tpb, 208 pages, Image, 2013, )
"Pillow Fight" (in #24-28, 2004–2005) collected as Pillow Fight (tpb, 48 pages, Amerotica, 2006, )
Heavy Metal Sci-Fi Special #2: "Devil and the Deep" (w/a, HM Communications, 2004)
Image Comics
24Seven Volume 1: "Fire Breathing City" (w, with James Stokoe, anthology graphic novel, tpb, 224 pages, 2006, )
Popgun Volume 2: "Sputz" (w/a, anthology graphic novel, tpb, 472 pages, 2008, )
Tokyopop Presents: King City #1-12 (w/a, 2009–2010) collected as King City (tpb, 424 pages, 2012, )
Prophet (w/a, with Simon Roy, Farel Dalrymple, Giannis Milonogiannis, Ron Ackins and others, Extreme Studios, 2012–2015) collected as:
Remission (collects #21-26, tpb, 136 pages, 2012, )
Brothers (collects #27-31 and 33, tpb, 172 pages, 2013, )
Empire (collects #32 and 34-38, tpb, 128 pages, 2014, )
Joining (collects #39-45, tpb, 168 pages, 2015, )
Earth War (collects Strikefile #1-2 and Earth War #1-6)
Multiple Warheads (w/a):
The Complete Multiple Warheads (tpb, 208 pages, 2013, ) collects:
Alphabet to Infinity #1-4 (2012–2013)
Down Fall (one-shot collection of all previously published short stories, 2013)
Multiple Warheads Vol. 2 (tbp, 128 pages, 2018, ) collects:
Entries from Island issues #1, #4, and #15
Ghost Throne (w/a, 2018) single issue, final chapter completed the serialized story arc that began in Island
The CBLDF Presents Liberty Annual '12: "King Kim: Barlartan Revenge" (w/a, anthology, 2012)
Thought Bubble Anthology #3: "One Night in Comicopolis" (w/a, with Cameron Stewart, 2013)
8HOUSE #1-ongoing (w, shared-universe/anthology series spearheaded by Graham, 2015–...)
Island #1-15 (w/a, anthology series featuring various artists from around the world edited by Graham and Emma Ríos, 2015–2017)
The Wicked + The Divine #17 (a, with Kieron Gillen, Jamie McKelvie and Matt Wilson, 2015)
Royal Boiler (w/a, collection of various art, 248 pages, 2018)
Rain Like Hammers #1-5 (w/a, 2021)
Other publishers
Oni Press:
Multiple Warheads #1: "The Fall" (w/a, 2007) collected in Complete Multiple Warheads (tpb, 208 pages, Image, 2013, )
Resurrection vol. 2 #5: "Under" (w/a, co-feature, 2009)
Arcana Studio Presents #6: "Creepsville" (a, with Bill Rude, Chris Wyatt and Kevin Hanna, Arcana Studio, 2009)
House of Mystery Annual #2: "Madame Xanadu" (a, with Matt Wagner, Vertigo, 2011) collected in Volume 7: Conception (tpb, 160 pages, 2012, )
Thickness #2: "Dirty Deeds" (w/a, anthology, 2011)
Dark Horse:
Dark Horse Presents #7: "The Speaker" (w/a, anthology, 2011)
Empowered: Internal Medicine (a, with Adam Warren, one-shot, 2014) collected in Unchained Volume 1 (tpb, 208 pages, 2015, )
Walrus (w/a, collection of sketches, drawings and rare comics from 2009 to 2012, 112 pages, PictureBox, 2013, )
The Infinite Corpse: 3 panel contribution (w/a, independent web comic)
Covers only
Hack/Slash: The Series #13 (Devil's Due, 2008)
Snakebomb Comix #1 (Snakebomb, 2011)
Clockwork Girl hc (HarperCollins, 2011)
Elephantmen #43 (Image, 2012)
Orc Stain #8 (Image, 2012)
Godzilla: The Half-Century War #3 (IDW Publishing, 2012)
Burn the Orphanage: Born to Lose #1 (Image, 2013)
Shutter #1 and #25 (Image, 2014 and 2016)
The Wicked + The Divine #8 (Image, 2015)
G.I Joe #3 (IDW Publishing, 2019)
Nomen Omen #4 (Image, 2020)
Bolero #2 (Image, 2022)
Other works
Love Is Calling Me (Cover art, music album by Joanna Wang, 2019)
Notes
References
External links
Living people
Artists from Oregon
American comics writers
1976 births
Writers from Oregon
|
```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 org.springframework.kafka.listener;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.BDDMockito.willReturn;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Supplier;
import org.apache.commons.logging.LogFactory;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.errors.RebalanceInProgressException;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.core.log.LogAccessor;
import org.springframework.data.util.DirectFieldAccessFallbackBeanWrapper;
import org.springframework.util.backoff.BackOff;
import org.springframework.util.backoff.FixedBackOff;
/**
* @author Gary Russell
* @author Francois Rosiere
* @author Soby Chacko
* @since 3.0.3
*
*/
public class FailedBatchProcessorTests {
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
void indexOutOfBounds() {
CommonErrorHandler mockEH = mock(CommonErrorHandler.class);
willThrow(new IllegalStateException("fallback")).given(mockEH).handleBatch(any(), any(), any(), any(), any());
TestFBP testFBP = new TestFBP((rec, ex) -> { }, new FixedBackOff(0L, 0L), mockEH);
LogAccessor logger = spy(new LogAccessor(LogFactory.getLog("test")));
new DirectFieldAccessFallbackBeanWrapper(testFBP).setPropertyValue("logger", logger);
ConsumerRecords records = new ConsumerRecords(Map.of(new TopicPartition("topic", 0),
List.of(mock(ConsumerRecord.class), mock(ConsumerRecord.class))));
assertThatIllegalStateException().isThrownBy(() -> testFBP.handle(new BatchListenerFailedException("test", 3),
records, mock(Consumer.class), mock(MessageListenerContainer.class), mock(Runnable.class)))
.withMessage("fallback");
ArgumentCaptor<Supplier<String>> captor = ArgumentCaptor.forClass(Supplier.class);
verify(logger).warn(any(BatchListenerFailedException.class), captor.capture());
String output = captor.getValue().get();
assertThat(output).contains("Record not found in batch, index 3 out of bounds (0, 1);");
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
void recordNotPresent() {
CommonErrorHandler mockEH = mock(CommonErrorHandler.class);
willThrow(new IllegalStateException("fallback")).given(mockEH).handleBatch(any(), any(), any(), any(), any());
TestFBP testFBP = new TestFBP((rec, ex) -> { }, new FixedBackOff(0L, 0L), mockEH);
LogAccessor logger = spy(new LogAccessor(LogFactory.getLog("test")));
new DirectFieldAccessFallbackBeanWrapper(testFBP).setPropertyValue("logger", logger);
ConsumerRecord rec1 = new ConsumerRecord("topic", 0, 0L, null, null);
ConsumerRecord rec2 = new ConsumerRecord("topic", 0, 1L, null, null);
ConsumerRecords records = new ConsumerRecords(Map.of(new TopicPartition("topic", 0), List.of(rec1, rec2)));
ConsumerRecord unknownRecord = new ConsumerRecord("topic", 42, 123L, null, null);
assertThatIllegalStateException().isThrownBy(() ->
testFBP.handle(new BatchListenerFailedException("topic", unknownRecord),
records, mock(Consumer.class), mock(MessageListenerContainer.class), mock(Runnable.class)))
.withMessage("fallback");
ArgumentCaptor<Supplier<String>> captor = ArgumentCaptor.forClass(Supplier.class);
verify(logger).warn(any(BatchListenerFailedException.class), captor.capture());
String output = captor.getValue().get();
assertThat(output).contains("Record not found in batch: topic-42@123;");
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
void testExceptionDuringCommit() {
CommonErrorHandler mockEH = mock(CommonErrorHandler.class);
willThrow(new IllegalStateException("ise")).given(mockEH).handleBatch(any(), any(), any(), any(), any());
ConsumerRecord rec1 = new ConsumerRecord("topic", 0, 0L, null, null);
ConsumerRecord rec2 = new ConsumerRecord("topic", 0, 1L, null, null);
ConsumerRecord rec3 = new ConsumerRecord("topic", 0, 2L, null, null);
ConsumerRecords records = new ConsumerRecords(Map.of(new TopicPartition("topic", 0), List.of(rec1, rec2, rec3)));
TestFBP testFBP = new TestFBP((rec, ex) -> { }, new FixedBackOff(2L, 2L), mockEH);
final Consumer consumer = mock(Consumer.class);
willThrow(new RebalanceInProgressException("rebalance in progress")).given(consumer).commitSync(anyMap(), any());
final MessageListenerContainer mockMLC = mock(MessageListenerContainer.class);
willReturn(new ContainerProperties("topic")).given(mockMLC).getContainerProperties();
assertThatExceptionOfType(RecordInRetryException.class).isThrownBy(() ->
testFBP.handle(new BatchListenerFailedException("topic", rec2),
records, consumer, mockMLC, mock(Runnable.class))
).withMessage("Record in retry and not yet recovered");
}
static class TestFBP extends FailedBatchProcessor {
TestFBP(BiConsumer<ConsumerRecord<?, ?>, Exception> recoverer, BackOff backOff,
CommonErrorHandler fallbackHandler) {
super(recoverer, backOff, fallbackHandler);
}
}
}
```
|
The list comprises all Carlin race results.
Current series results
FIA Formula 2
In detail
FIA Formula 3
* Season still in progress
In detail
(key)
Macau Grand Prix
BRDC British Formula 3 Championship / GB3 Championship
* Season still in progress
F4 British Championship
* Season still in progress
†Hedley drove for Fortec Motorsport until round 5. Bolger drove for JHR Developments in round 10.
Formula 4 UAE Championship
F4 Spanish Championship
F1 Academy
Complete former series results
British Formula 3 Championship
[B] Drivers and classification in the B or National class.
[G] Guest drivers, no points awarded.
GP2 Series
† — Includes points scored for ART Grand Prix
In detail
(key) (Races in bold indicate pole position) (Races in italics indicate fastest lap)
Formula Nissan/Renault 3.5 Series
†Includes points scored with EuroInternational.
FIA Formula E
‡ FanBoost in Formula E.
† These drivers also drove for other teams during the season and their final positions include all team results.
D.C. = Drivers' Championship position, T.C. = Teams' Championship position, NC = Not Classified.
[G] Guest driver
GP3 Series
In detail
(key) (Races in bold indicate pole position) (Races in italics indicate fastest lap)
A1 Grand Prix Series
Eurocup Formula Renault 2.0
Porsche Supercup
Formula 3 Euro Series
† The 2012 Formula 3 Euro Series was run in partnership with the 2012 European Formula 3 Championship, with eight of the ten European F3 rounds counting towards the F3 Euro Series point tallies.
FIA European Formula 3 Championship
As Carlin
As Jagonya Ayam with Carlin
In 2014 and 2015, Carlin competed with two teams in European F3, under the names of Carlin and Jagonya Ayam with Carlin.
IndyCar Series
(key)
Euroformula Open Championship
†Trulli drove for Drivex School until round 3. Mansell drove for Team Motopark from round 7 onwards.
Indy Lights
In detail
(key)
Japanese Formula 3 Championship
As OIRC team YTB by Carlin
References
GP2 Series teams
|
The FN 503 is a polymer frame striker-fired subcompact semi-automatic pistol manufactured in Columbia, South Carolina, by FN America, a division of FN Herstal. Introduced in March 2020, it is chambered in 9×19mm Parabellum and is intended for concealed carry.
As of August 2023, the FN 503 was discontinued.
Features
The FN 503 is a striker-fired handgun with a stainless steel slide. Subcompact in size, its overall length is with a barrel length of and a width of . The three-dot iron sights are low-profile, while trigger pull averages . Magazines are either 6-round with a pinky extension or 8-round with a grip sleeve.
The FN 503 uses the "design, performance and reliability standards" of the FN 509, a full-sized pistol introduced in 2017.
References
External links
FN 503 Concealability and Reliability of the Highest Caliber via YouTube
9mm Parabellum semi-automatic pistols
FN Herstal firearms
Semi-automatic pistols of the United States
Weapons and ammunition introduced in 2020
|
```java
/**
* 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
*/
package org.apache.weex;
import android.view.View;
import org.apache.weex.ui.component.WXComponent;
/**
* Created by sospartan on 14/06/2017.
*/
public interface ComponentObserver {
/**
* Called after component is create.
* Notice: View is not created at this moment.
* @param component
*/
void onCreate(WXComponent component);
/**
* Called before component destroy.
* @param component
*/
void onPreDestory(WXComponent component);
/**
* Called when component's view is created
* @param component
* @param view
*/
void onViewCreated(WXComponent component,View view);
}
```
|
```javascript
function hello(a) { sayHi(); }
```
|
```objective-c
struct gcm_args {
unsigned char* auth_final_block;
const unsigned char* plaintext;
unsigned char* ciphertext;
unsigned long long plain_block_num;
unsigned char* text_final_block;
unsigned long long plain_len;
const unsigned char* additional_data;
unsigned long long auth_block_num;
unsigned long long additional_data_len;
unsigned char* iv;
const unsigned char* expanded_key;
const unsigned char* expanded_h_key;
unsigned char* tag; // const in case of decrypt
};
// Layout of keyhash expanded key
// *------------------------------------------------------*
// | (H << 1) mod (reduction polynomial) (128-bit) |
// | (H^2 << 1) mod (reduction polynomial) (128-bit) |
// | H (128-bit) |
// *------------------------------------------------------*
// gcm_decrypt return 0 in case content of tag buffer is equal
// to computed authentication hash. Otherwise, return > 0
//AES-128 functions
extern "C" void aes128_key_expansion(unsigned char* expanded_key, const unsigned char* key);
extern "C" void aes128_keyhash_init(unsigned char* expanded_h_key, const unsigned char* expanded_aes_key);
extern "C" void gcm128_encrypt(struct gcm_args* args);
extern "C" int gcm128_decrypt(struct gcm_args* args);
//AES-256 functions
extern "C" void aes256_key_expansion(unsigned char* expanded_key, const unsigned char* key);
extern "C" void aes256_keyhash_init(unsigned char* expanded_h_key, const unsigned char* expanded_aes_key);
extern "C" void gcm256_encrypt(struct gcm_args* args);
extern "C" int gcm256_decrypt(struct gcm_args* args);
```
|
Tamara Bösch (born 5 June 1989 in Lustenau) is an Austrian handballer who plays for HC Leipzig and the Austrian national team.
Achievements
Swiss Championship:
Winner: 2009, 2011
Swiss Cup:
Winner: 2009, 2010
References
External links
Profile on the Austrian Handball Federation official website
1989 births
Living people
Austrian female handball players
Austrian expatriate sportspeople in Germany
Expatriate handball players
Austrian expatriate sportspeople in Switzerland
Sportspeople from Vorarlberg
People from Lustenau
|
Evamaria Bath (12 April 1929 – 18 June 2023) was a German stage, film and television actress.
Bath died on 18 June 2023, at the age of 94.
Selected filmography
The Call of the Sea (1951)
Natürlich die Nelli (1959)
The Red Snowball Tree (1974, East German dub)
References
Bibliography
Peter Cowie & Derek Elley. World Filmography: 1967. Fairleigh Dickinson University Press, 1977.
External links
1929 births
2023 deaths
German film actresses
German television actresses
German stage actresses
Actresses from Berlin
|
```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 com.haulmont.cuba.core.sys.dbupdate;
import com.haulmont.bali.util.URLEncodeUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.core.io.Resource;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class ScriptResource {
protected String dir;
protected String name;
protected String path;
protected Resource resource;
public ScriptResource(Resource resource) {
try {
this.resource = resource;
this.name = resource.getFilename();
this.path = URLEncodeUtils.decodeUtf8(resource.getURL().getPath());
this.dir = StringUtils.substringBeforeLast(this.path, "/");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public String getName() {
return name;
}
public String getPath() {
return path;
}
public String getContent() throws IOException {
return IOUtils.toString(resource.getInputStream(), StandardCharsets.UTF_8);
}
public String getDir() {
return dir;
}
@Override
public String toString() {
return path;
}
}
```
|
```go
package protocb
type couchbaseConfig struct {
async bool
snapshotInterval int
}
type CouchbaseOption func(*couchbaseConfig)
func WithAsync() CouchbaseOption {
return func(config *couchbaseConfig) {
config.async = true
}
}
func WithSnapshot(interval int) CouchbaseOption {
return func(config *couchbaseConfig) {
config.snapshotInterval = interval
}
}
```
|
The Plaque of Merit is awarded to institutions and organisations outside the IHF.
Levels
There are two levels: gold and silver.
Gold Plaque of Merit
The Plaque of Merit in Gold recognises above-average services, over many years, to the development of handball and/or in association with the IHF.
Recipient of IHF Gold Plaque of Merit
Silver Plaque of Merit
The Plaque of Merit in Silver is awarded for particular contributions to the development of handball and/or in association with the IHF.
Award
The recipients are selected and the plaques awarded by the Council. The Executive Committee, the Council, the continental federations and member federations are all entitled to suggest recipients for the awards.
External links
IHF Statuts Chapter XXI - Regulations of Awards
International Handball Federation awards
|
Walmington-on-Sea is a fictional seaside resort that is the setting of Dad's Army during the Second World War, including the BBC Television sitcom (1968-1977), the BBC Radio 4 series and two feature films (1971 and 2016).
Walmington-on-Sea is on the south coast of England which, following the fall of France and the evacuation of the British Expeditionary Force from Dunkirk, found itself on the front line against Hitler. It is situated in Sussex and the nearest large town is Eastbourne, where Captain Mainwaring was educated at the local grammar school.
The series followed the adventures and misadventures of members of a fictional platoon of the Home Guard - a (real) WWII volunteer army that was formed from those ineligible for conscription by age, minor physical inability or occupation, to defend the United Kingdom from German invasion following the fall of France.
Amenities and filming locations
Over the nine television series, the action is set in various places in Walmington-on-Sea, the interiors of which were built in the television studios, while the exterior scenes were filmed at various Norfolk locations. Those included a pleasure pier (filmed in Great Yarmouth) with a 20-foot (6m) wide gap blown in the middle to prevent it from being used as a landing stage by invading armed forces. The beach is protected with barbed wire and other defences including mines, pillboxes and tank traps.
Other locations, typical of a seaside town during the Second World War, included a sweet shop, The Novelty Rock Emporium, at least two banks (the fictional Swallows Bank, which appeared in early episodes, and the real Martins Bank), the Marigold tea room, Anne's Pantry, the Dutch Oven, Corporal Jones's butcher's shop, Hodges' greengrocers, Frazer's undertakers, a cinema and numerous pubs including the Red Lion, which all suggest it was a reasonably sized place. There is also a Free Polish Club for Polish servicemen. In common with most real British towns, Walmington-on-Sea has a church, Saint Aldhelm's, with a hall next door which is the setting for various community events in the episodes such as the Christmas pantomime and a place for the Sea Scouts to parade. It is also where the Walmington-on-Sea Home Guard platoon muster on parade nights.
Many outdoor scenes were filmed at Thetford, an inland town in Norfolk. The 1971 film, Dad's Army, moved location to Chalfont St Giles, even further from the coast. The 2016 film, Dad's Army, was filmed even more distantly, in Yorkshire.
Thetford's Guildhall (today the home of the Dad's Army Museum) became Walmington-on-Sea's Town Hall. The Guildhall featured in the 1972 episode Time on My Hands, in which a German Luftwaffe pilot dangled from the clock tower when his parachute became caught in the clock's hands. The Guildhall was also used in the 1974 episode "The Captain's Car". The distinctive flint cottages in Thetford's Nether Row appeared in four episodes: "Man Hunt", "The Armoured Might of Lance Corporal Jones", "The Big Parade" and "Time on My Hands". Mill Lane was used in "The Deadly Attachment", while Thetford's real-life Palace Cinema (now a bingo hall) doubled as Walmington-on-Sea's Empire Cinema in two episodes – "The Big Parade" (1970) and "A Soldier's Farewell" (1972).
Brandon railway station was used for exterior shots of Walmington-on-Sea railway station, while the platforms of Weybourne Station on the preserved North Norfolk Railway (a heritage steam railway) stood in for the platforms at Walmington-on-Sea station in the episode "The Royal Train".
References
External links
Description of Walmington-on-Sea
Location of Walmington-on-Sea
Dad's Army
Fictional populated places in England
|
```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.
*/
/*
* This is an example fuzzer targeted a given architecture. The point of this is
* that the general fuzz_bfd fuzzer has too large reacability which makes it
* difficult to reach the entire codebase in practice. The goal is to create
* more targeted fuzzers that are more likely to explore a given code area.
*
*/
#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>
static int bufferToFile(char *name, const uint8_t *Data, size_t Size) {
int fd = mkstemp(name);
if (fd < 0) {
printf("failed mkstemp, errno=%d\n", errno);
return -2;
}
if (write(fd, Data, Size) != Size) {
printf("failed write, errno=%d\n", errno);
close(fd);
return -3;
}
close(fd);
return 0;
}
int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
char tmpfilename[32];
if (bfd_init() != BFD_INIT_MAGIC)
abort();
/*
char **names = bfd_target_list();
while (*names != NULL) {
printf("Name: %s\n", *names);
names++;
}
*/
bfd_cleanup cleanup = NULL;
strncpy(tmpfilename, "/tmp/fuzz.bfd-XXXXXX", 31);
if (bufferToFile(tmpfilename, Data, Size) < 0) {
return 0;
}
// bfd *file = bfd_openr (tmpfilename, "elf32-frv");
bfd *file = bfd_openr(tmpfilename, "pef");
if (file == NULL) {
remove(tmpfilename);
return 0;
}
if (!bfd_read_p(file) ||
(unsigned int)file->format >= (unsigned int)bfd_type_end) {
bfd_close(file);
return 0;
}
bool doAnalysis = false;
if (bfd_seek(file, (file_ptr)0, SEEK_SET) == 0) {
file->format = bfd_object;
cleanup = BFD_SEND_FMT(file, _bfd_check_format, (file));
if (cleanup) {
doAnalysis = true;
cleanup(file);
}
file->format = bfd_unknown;
}
if (file != NULL) {
bfd_close(file);
}
if (doAnalysis) {
// We have a file with the target data we want.
// Let's open as a write file this time, which should trigger
// more actions on the code when calling bfd_close.
// TODO: do more processing on this, e.g. use the file as
// input to some of the other utilities.
bfd *wFile = bfd_openw(tmpfilename, "pef");
if (file != NULL) {
bfd_close(wFile);
}
}
remove(tmpfilename);
return 0;
}
```
|
RTÉ2 is an Irish free-to-air television channel operated by public service broadcaster RTÉ. It was launched in 1978 as the Republic of Ireland's second television channel.
History
In the 1970s, the Irish government considered three options for the introduction of a second television service: the re-transmission of BBC1 Northern Ireland; authorization of an independent commercial service; or charging RTÉ with the establishment of a second national channel. It was the last of these that was finally chosen.
The channel—only the second in the Republic—began transmissions at 20:00 on 2 November 1978, opening with a broadcast of a gala ceremony from Cork Opera House. Owing to a technical error, audio from BBC2 was played during the countdown instead of the proper soundtrack. When the channel commenced programmes, there was no audio for the initial 15 seconds.
The first broadcast on RTÉ 2 was on 6 June 1978. Initial broadcasting was limited to evenings. It was largely aimed at those in "single channel land." Programmes included The Streets of San Francisco and Duchess of Duke Street.
The opening night's line up was as follows:
20:00 – RTÉ 2 presenters Bernadette Ni Ghallchoir, Roisin Harkin and Raymond Maxwell introduce viewers to Ireland's second national television channel. The National Anthem followed.
20.05 – The President of Ireland, Patrick Hillery introduces the new service.
20.06 – First Night, a gala performance aired live from the Cork Opera House in Cork City, hosted by Mike Murphy. Guest stars included The Chieftains, Gemma Craven, Val Doonican, The George May Dancers, The Irish Ballet Company, The Montford Singers, John O'Connor, Maureen Potter, Colm C.T. Wilkinson and Lena Zavoroni. There were specially recorded inserts from British and American stars such as Bruce Forsyth, Ronnie Barker, Liberace, Sammy Davis Jr, Michael Parkinson, Andy Williams, Dana and Eamonn Andrews.
21.30 – The first movie to be shown on RTÉ 2, Bullitt, starring Steve McQueen, Robert Vaughan and Jacqueline Bisset.
23.30 – Newsnight, a late night summary of the national and international news headlines.
23.35 – The channel closed down, ending the first night on air.
RTÉ 2 (1978–1988)
Up to 60% of the Republic of Ireland could receive UK channels via spillover or via cable. Cable in the republic was only permitted in areas of spillover up to the mid-1980s, to provide viewers with better reception of channels they could already receive over the air. Hence RTÉ 2 was aimed at those that did not have the UK channels. To this end one of their main remits was the re-broadcasting of UK programming to Irish audiences, that would not otherwise be seen on RTÉ 1.
On the opening night of RTÉ 2, one of the channels announcers said "From ten to seven each weekday, three o'clock on Saturdays and six o'clock on Sundays, RTÉ 2 will be bringing you the best of BBC, ITV and other first rate programming", in error meaning to say "from seven to ten". In the first two years of the channel, it would normally open at 6pm and close down for the night at 11.30pm.
British soap drama Coronation Street aired on the channel simultaneously with ITV's broadcasts of the programme (this continued until 1992 when it was put on RTÉ 1 due to the Olympic Games coverage). It broadcast much live programming from the BBC and ITV including Top of the Pops. However, the channel in its initial format was not considered a success. It was on air from 18:00 until 23:30 during the week, with an earlier start around 15:30 at weekends.
However, by 1987, RTÉ 2 rebranded as part of RTÉ's 25th celebrations relaunched with a new cooperate logo and TV idents, this would be the first time that the RTÉ corporate logo would be seen on RTÉ2. While the rebrand was a small success for the channel it was felt that RTÉ 2 and RTÉ 1 needed more specific audiences. RTÉ 2 at this stage was becoming more and more associated with youth orientated programming and sports programming (especially as UK and other international channels were becoming more and more available across the country). In 1988, the majority of sporting and children's programming was moved to Network 2, the new name for RTÉ 2.
Network 2 (1988–2004)
In September 1988, RTÉ 2 was given a major revamp and became Network Two. In addition to the launch of a new vivid red, blue, and green logo, the channel now came on air at 14:30. The Den was moved to the channel, along with most youth and children's programming. Jo Maxi was launched as the youth strand. Sports Stadium took up the entire Saturday afternoon schedule, and all sports programming was aired on the channel, along with Irish language programming. A late night news bulletin, Network News, was followed by the controversial but highly successful chat show / soap opera Nighthawks presented by Shay Healy, and produced by David Blake-Knox.
This relaunch was a big success, and Network Two remained stable until the mid-1990s. A new logo – referring to the channel as RTÉ Network 2 (though the "RTÉ" part was not referred to by announcers) – was launched with the new RTÉ logo in 1995. By this time, RTÉ Network 2 broadcast from mid-morning onwards, with educational programmes during the day. Also during this era, the channel experimented with late night broadcasts at weekends, under The End brand, anchored by Barry Murphy and Sean Moncrieff. Broadcast hours were extended to 03:00 every day with a new service called The Night Shift.
N2 (1997 – 2004)
There was another major revamp in 1997, and the channel was visually rebranded as "N2", though announcers continued to refer to "Network 2". N2 brought about perhaps as big a change as the original relaunch, RTÉ branding was dropped from the station almost completely, with home produced programmes now being referred to as "N2 Productions" (foreign imports were "N2 Presentations"). A futuristic logo along with a series of unusual graphical idents were developed. In-vision announcing returned. More importantly, the channel's line-up was completely refreshed. The late night schedule was completely revamped, with the launch of News 2—a tailored bulletin for young people—followed by a talk show, Later on 2. Monday nights became comedy nights, with the launch of home-produced comedy such as Don't Feed The Gondolas. Elsewhere theme nights became a regular fixture, particularly on Fridays and Saturdays. The Den was now broadcast all day until 18:00 and was renamed Den 2.
Not all the changes were universally welcomed, with the "N2" era, RTÉ cancelled its long running Saturday sports programme, Sports Stadium in 1997. Since then, RTÉ has not regularly aired live sports (or at least, as part of a regular schedule) on Saturday afternoons, though major events are still covered.
Many of the innovations of the N2 era had faded out by 2003. The idents had been replaced by simpler creations, the in-vision continuity had been scrapped again. Later on 2 had more-or-less ended (one of the strands continues as The View on RTÉ One). In September 2003, News 2 reverted to the regular RTÉ News format (as RTÉ News on Two).
From September 2003, continuity announcers and trailers began to refer to the channel by the fuller title of "RTÉ Network Two", in line with a new RTÉ initiative to promote the corporate branding. The main channel idents never changed, and said merely "N2" (although a newly introduced on-screen DOG said "RTÉ N2".). And finally in 2004 Network 2 was relaunched as RTÉ Two, in line with its sister channel RTÉ One.
RTÉ Two (2004–2014)
RTÉ decided the channel needed another revamp to keep it fresh. The channel's name reverted to RTÉ Two on the morning of 2 October 2004, with a themed evening of programmes called "Farewell Network 2" beginning at 20:00, featuring Podge and Rodge. The new logo is similar in style to the current RTÉ One logo. The new branding is designed to promote the Irishness of the station, green is the dominant colour. New strands were developed. In particular, the number of Irish made programmes has increased, though some of this is made up of a new strand of early evening repeats. The idents from this time were based on a Green Room theme.
The latest change has been a complete rebrand and relaunch of The Den, on Saturday 17 September 2005, with the id Two strand becoming TTV on the following Monday. In September 2009, TTV relaunched as Two Tube.
RTÉ Two got a new look on 17 September 2009. The new idents were created by RTÉ Graphic Design. Programme cutbacks saw the end of 24-hour broadcasting on the channel, with Euronews filling the down-time. Teleshopping was also introduced for the first time.
Continuing with the corporate branding of RTÉ radio and Television stations RTÉ Two's iconic children's brand The Den ended on 20 September 2010. The Den was replaced by TRTÉ, while Den Tots was replaced by RTÉjr; this was due mainly to the onset of digital TV on which RTÉjr is available as a separate channel. Two Tube remains as the teenage block of programming.
RTÉ2 (2014–2017)
From 22 September 2014 RTÉ Two became RTÉ2 and presented a new schedule of programming. The channel established itself as the "voice for the under 35s" where the new schedule continued with new seasons of New Girl, The Big Bang Theory, Grey's Anatomy, Brooklyn Nine-Nine, Masters of Sex, Devious Maids, The Americans, Agents of S.H.I.E.L.D. and the final season run of Mad Men. Brand new imported shows included Outlander, Gotham, Resurrection, iZombie and CSI Cyber. RTÉ2 confirmed it had secured broadcasting rights for two Danish drama series 1864 and The Saboteurs: The Heavy Water War, both broadcasting in 2015. In terms of home-produced Irish programming RTÉ2 confirmed the return of Other Voices (Season 13), Maia Dunphy's What Women Want (Season 2), Second Captains Live, Savage Eye (final series), The Republic of Telly, Damo & Ivor, The Fear and the newly created youth orientated news service News Feed. RTÉ2 also confirmed new Irish reality programmes including Holding Out for a Hero, Connected, Full Frontal, Bressie's Teenage Kicks, and Drunk and #Trending.
RTÉ2 continued to focus on major sporting events and the channel will showcase Irish films in association with the Irish Film Board. TRTÉ will play a major role in the daytime schedule on the channel. Two Tube will continue to air from 17:30 until 19:00. It is proposed by RTÉ to launch RTÉ2+1 in efforts to raise much needed revenue.
By 2015, RTÉ2 began to focus on imported programming from Denmark, Iceland and Germany. The channel increased its output of Irish themed reality series.
RTÉ2 (2018 – )
On 3 November 2018 RTÉ2 celebrated its 40th Anniversary and began to offer vintage clips of shows from RTÉ2 on the RTÉ archives website.
Much of the innovation and local programming on RTÉ2 has been cut by RTÉ. Outside of sports programming RTÉ2 programming includes First Dates (Irish TV series) and a DIY show called Home Rescue. Some innovations remain such as Other Voices (Irish TV series) and highlights from the RTÉ Choice Music Prize.
With Children's content now starting at 08:15 in the morning with RTÉjr, following a simulcast of Euronews, and finishing at 4:30.
RTÉ2 HD
The HD channel launched on Saorview on 27 May 2011. The service broadcasts sporting programming from national to international events, documentaries, movies and American, Canadian, and Australian programming in high-definition 1080i.
On 15 March 2012, RTÉ2 HD was added to UPC Ireland.
RTÉ2 HD was added to Sky on 16 May 2012. RTÉ2 HD was due to launch on Sky on 14 May 2012, but was delayed by two days due to technical problems.
Format
The channel simulcasts content from RTÉ2 SD and upscales SD content into HD. All other content on the channel is made available entirely in HD, this includes Gaelic Athletic Association, Champions League, World Cup, Olympic Games, Pro14 sporting content, USA television series and movies.
RTÉ2 +1
RTÉ2 +1 launched on 19 February 2019, and it broadcasts daily from 19:00 until 02:00 Monday to Friday and 12:00 until 02:00 Saturday and Sunday. The channel launched only on Saorview and it will eventually roll out onto other platforms such as Sky Ireland and Virgin Media Ireland.
The development of RTÉ2 +1 has been a long process however in May 2018, it was reported by The Irish Times that RTÉ have requested permission from the Department of Communications to launch RTÉ2 +1.
Astra 2F (Sky)
On 13 December 2018, RTÉ2 +1 began test broadcasts on Astra 2F under the label 5493 using frequency 11914 H 27500 5/6 DVB-S QPSK. Testing included showing Sky Sports channels and a previously aired weather forecast on repeat. This frequency is the same used by RTÉ One SD, RTÉ One +1, RTÉ2 SD and others. Astra 2F is a satellite that Sky and Freesat (in the UK) use.
On 19 February 2019, RTÉ2 +1 launched on Saorsat (and Saorview) only. From 19 February to 20 July 2019, RTÉ2 +1 broadcast the same on Astra 2F as on Saorsat and Saorview. On 20 July 2019, RTÉ2 +1 stopped broadcasting on Astra 2F showing a "No signal" message.
On 24 February 2021, RTÉ2 +1 reappeared on Astra 2F on the same frequency as before using the same label (5493).
On Wednesday 10 March 2021, RTÉ2 +1 was added to Sky on channel 202.
Logos
Budget
The following figures were issued by RTÉ as part of their annual reports in 2008 and 2012:
Total costs
Profit and loss
Breakdown of Irish productions
The table below outlines RTÉ2's total in-house and commissioned programming by genre in 2008 and 2012:
Programming
RTÉ2 provides a broad range of programming which is mainly targeted towards young people up to 45-year-olds. Between 06:00 to 18:30 kids and teens programming is served by RTÉjr (separate to the channel) and the teenage strands TRTÉ and Two Tube. From 19:00 onwards, RTÉ2 provides a wide range of programming from Irish produced content, sports, comedy, dramas, films and acquisitions from North America, Australia, the UK and Central Europe. RTÉ2 has a strong tradition of broadcasting many US TV shows prior to other European broadcasters, though this has slightly changed in recent years.
Films are also regularly aired on the channel especially Irish-European cinema and International cinema. Until September 2014, RTÉ2 had stands such asTwo Wild (nature documentaries), Two Extreme (extreme sports/adventure documentaries), and RTÉ Sport on Two, these strands were axed in 2014 but the strands contents play an important role in the current schedule.
RTÉ 2 Controller
Dick Hill was RTÉ 2's first controller until 1994.
During the time of the 1997 rebrand of the channel as N2 they had placed the Head of Schedule as "controller" of the channel. Up until then, the channel was run side by side RTÉ One under RTÉ Television. N2 was a successful relaunched of the channel in the late 1990s.
Andrew Fitzpatrick was poached to take control of RTÉ scheduling from TV3; however, N2 basically reverted to being part of the overall RTÉ Television structure.
With no dedicated channel controller until then, in May 2011 it was announced by RTÉ that Eddie Doyle had been given the position of commissioning editor at RTÉ Two. Eddie Doyle was RTÉ Commission Editor of Entertainment.
In May 2013 RTÉ announced Bill Malone as RTÉ Two's controller. Eddie Doyle became Head of Comedy, Talent Development and Music at RTÉ.
In July 2016 Bill Malone moved to rival channel TV3 (now Virgin Media Television) as Head of Programming. Channel Control at RTÉ One, Adrian Lynch, took over the role at RTÉ2 and eventual became Director of Channels and Marketing at the broadcaster in 2018.
Imported programming
1978–1988
RTÉ 2 was original set up to provide Irish viewers with retransmission of BBC and ITV programming. In 1978 it introduced a simulcast of many British programmes including Top of the Pops. Other UK shows included Coronation Street (which began simulcasting from 1983), Porridge, Mastermind, Never the Twain, Treasure Hunt and Wogan and American shows such as The Dick Cavett Show, Tales of the Unexpected, My Friend Rabbit, Crazy Like a Fox and The Tracey Ullman Show. They also broadcast the Australian soap opera A Country Practice. In 1988 RTÉ did a major revamp of the service, focusing more on Sports, Children's TV, Irish Programming as RTÉ 2 was still behind both UTV and BBC One NI in the ratings.
1988–1993
As Network 2 the service still focused strongly on imported programming, RTÉ would now look to have first runs of US programming before other European networks. In the early years Network 2 broadcast US sit-coms Monday to Friday at 21:00 such as The Golden Girls, Cheers, The Days and Nights of Molly Dodd, Check It Out and Murphy Brown. They also broadcast Knots Landing and Falcon Crest. They also began broadcasting the long running Australian soap opera Home and Away, while A Country Practice moved to RTÉ One. In 1992 Coronation Street moved to RTÉ One. Other US shows at this time included Head of the Class, Ferris Bueller and Eerie Indiana.
1993–1997
During the 1990s Network 2 began to expand it schedule to cover morning and late night television. Imports still played a major part of the schedule with first showings of popular 1990s TV such as Friends, The X Files, Nowhere Man, My So-Called Life, but also Late Night and Daytime repeats of Yes Minister, The Fall and Rise of Reginald Perrin, Cheers, The Beverly Hillbillies, Peyton Place, The Mary Tyler Moore Show, MacGyver and also the morning strand of Open University. At 18:00 they began showing many US teen sitcoms such as California Dreams, Saved by the Bell and Harry and the Hendersons, and The Fashion Show.
1997–2004
During the late 1990s the schedules began to increase in size again. All of the daytime repeat programmes were replaced by Children's television while Late Night TV was extended until 2 am each morning with shows like, Profiler, Millennium, Star Trek: Voyager (only airing the first season), Stargate SG1 and some Australian serials including Water Rats and Murder Call. In 2001 they began broadcasting the Australian soap Neighbours. Popular prime time US programmes included Friends, The Parkers, Ally McBeal, 24, Dawson's Creek, Smallville, Jessie, Frasier and Boston Public. In 2000 Network 2 broadcast all episodes of the cult favourite Freaks and Geeks and finished the series before NBC did in the US. During this time they also began airing The Simpsons (also airing on Sky1) which had not been seen on the channel since The Tracey Ullman Show in the late 1980s.
2004–2013
Renamed in 2004 as RTÉ Two, the channel still had a heavy emphasis on imported programming. Its late night schedule contained imports including Rules of Engagement, 24, Rescue Me and Smallville. During this time, the channel also showed Cougar Town, Flash Forward, Lost, The Good Wife, CSI, Criminal Minds, Desperate Housewives, Grey's Anatomy, Sons of Anarchy, Life with Boys and Mr. Young.
RTÉ2 also airs American programmes such as The Simpsons (currently airing Season 20 weekdays at 18:00), 90210, Revenge, Law & Order, Criminal Minds, The Big Bang Theory, Greys Anatomy, Worst Week and Private Practice. Australian soaps Neighbours and Home and Away air along with Irish programmes such as Katherine Lynch's Wonderwomen, The Podge and Rodge Show. Other well known US shows on RTÉ Two include Lost, Ugly Betty, Prison Break, CSI: Crime Scene Investigation, CSI: Miami, CSI: NY, Desperate Housewives, The Americans, New Girl and 2 Broke Girls. It also airs Smallville, Sons of Anarchy, Eli Stone, Mr. Sunshine after midnight on weekends, and British shows such as Shameless and The Thick of It.
It has also aired Seasons 5, 6, 7, 8 and 9 of NCIS and also Season 2 of Hawaii Five-0. It is currently showing NCIS Season 10 on Saturdays at midnight and Hawaii Five-0 Season 3 on Sunday nights. The Walking Dead, Under The Dome and Person of Interest are other US shows added to the channel's schedule.
2014–2016
In 2014, RTÉ Two began to focus more on Irish music programming for the first time in its history the annual Choice Music Prize was aired on television, previously only available on radio. It continued to air the critically acclaimed music series Other Voices for an eleventh season. In August 2014, RTÉ Two televised over 8 hours of Electric Picnic coverage from Stradbally, County Laois, this was the first time that the channel aired the annual music festival. On 2 September 2014, RTÉ began to air new comedy series Mom. Additional shows to begin airing in 2014 include Gotham. A new fashion and entertainment series produced in-house by RTÉ called #Trending will be hosted by Darren Kennedy.
As part of the autumn 2014 schedule RTÉ Two began airing Mom. Vikings premiered on the channel in early January 2014 and series 2 aired from October 2014. In 2015, RTÉ2 returned to broadcasting non-English speaking content; these included Nordic dramas The Saboteurs and 1864. American Odyssey was added to the summer 2015 line-up, since axed by ABC. News shows included CSI Cyber. Season 3 of The Americans was added to the summer schedule. Other non-English speaking programming were added to the RTÉ2 schedule in late 2015, including the critically acclaimed German drama Deutschland 83.
2016–
The summer 2016 schedule was largely made up of sports programming such as GAA, Euro 2016 and Summer Olympics 2016.
In early 2016, the broadcaster confirmed it would air the mini-series The X-Files, which began airing on 26 January. iZombie was another addition to their schedule, along with Icelandic crime drama Trapped. In Spring 2016, the channel debuted First Dates Ireland to positive reception.
Irish-produced programming
Reality TV
The 2000s like many other broadcasters RTÉ2 have had several reality based TV shows.
In 2003, Network 2 set out to find their news TV presenter in a reality show called The Selection Box; the eventual winner was Caroline Morahan.
RTÉ2 also produced two series of the employment reality show No Experience Required, three prospective candidates are evaluated over the course of a week for a vacant position in a top company, the show follows them through interview stages and tasks set out by their prospective employees.
In 2008, RTÉ Two broadcast Hollywood Trials. It follow a group of young actors travelling to make it big in LA. The actors where selected by Hollywood acting guru Margie Haber. Those selected to travel with Margie to LA included Chris Newman from the RTÉ Two drama Love is the Drug, George McMahon from RTÉ One soap opera Fair City and Michael Graham of Boyzone fame. Nelvana
Hollywood Trials was then followed by The Model Agent. The model agent in question was Ellis and with help of Erin O'Connor as the girls mentor she picked Carrie-Anne Burton for a contract with Independent Models, one of the world's leading modelling agencies and a cover for Image magazine, one of the Ireland's most high profile and respected fashion titles. A similar series called The Model Scouts is currently in production.
Do the Right Thing, another reality series, began in September 2010 and was presented by Lucy Kennedy and Baz Ashmawy, in search of Ireland's ultimate volunteer.
In 2011 Masterchef Ireland began airing on the channel.
RTÉ2 also ran spin-off serials to RTÉ One's reality shows, such as You're a Star Uncut, Cabin Fever, and Treasure Island Uncovered.
First Dates (Irish TV series) began broadcasting in 2018, with its 8th season airing in 2023.
Drama
In the first two decades of RTÉ2, little original drama was produced for the channel; often RTÉ would just repeat their dramas on the channel such as Fair City and Glenroe. RTÉ did place some emphasis on short film in the RTÉ series Short Cuts. Short films remain on RTÉ2 most Monday nights at 11:30; these shorts are not just taken from RTÉ co-financed productions but also from independent producers around the world.
RTÉ2's most successful drama was a drama/comedy/chat show entitled Nighthawks presented by Shay Healy. This was produced as a pseudo-documentary about the behind the scenes of the television production, it featured many well known Irish comedians, however unlike the mockumentary The Larry Sanders Show, Nighthawks featured real interviews and was created by David Blake Knox, who went on to be controller of Network 2 until 1998. Gerry Ryan had a similar format show called Gerry Ryan Tonight during the 1990s.
2000–2008
From 2000 to 2008, RTÉ were committed to providing new and original drama on RTÉ2 each Monday night each autumn. The dramas had mixed reviews but they included Paths to Freedom (2000), Bachelors Walk (2001–2003), The Big Bow Wow (2003), Pure Mule (2004), Love is the Drug (2004) and Prosperity (2007). Raw was RTÉ2's last Monday night drama; it received mixed reviews but it reached on average 250,000 viewers each week against RTÉ One's Prime Time Investigates and TV3's The Apprentice; Raw's second series ran on RTÉ One. Most of RTÉ2's drama output was aimed at a younger audience than that of RTÉ One's and it often contained bad language and sex scenes.
RTÉ ended their RTÉ2 drama's in 2008 with the first series of Raw, choosing to air its second series on RTÉ One. RTÉ are not currently looking for drama specifically for RTÉ2 which brings to an end a significant amount of work brought to the channel from RTÉ's drama department and independent producers. Many of the dramas of this era on RTÉ were seen as experimental but also highly modern and innovative.
Comedy
Monday night was comedy night on RTÉ2 from 1997 to 2006. Many US sitcoms were intermixed with live Irish comedy such as Don't Feed The Gondolas (DFTG), The Panel, The Podge and Rodge Show, A Scare at Bedtime with Podge and Rodge, @LastTV, The Liffey Laughs, The Blizzard of Odd, The Byrne Ultimatum and Night Live.
RTÉ Young Peoples
RTÉ Young People's department oversees programming for under-5s, 5- to 12-year-olds and teenage audiences. As part of RTÉ2's redevelopment in 1988 as Network 2, most of RTÉ's young people's programming moved from RTÉ One to Network 2.
Children's television
Dempsey's Den was hosted by Ian, Zig, Zag and Zuppy. It moved to Network 2 from RTÉ One, and broadcasting for an extra hour from 15:00 to 18:00. Network 2 would start the day 14:30 with Bosco a pre-school television show. All children's television moved to Network 2 when it rebranded in 1988. When Ian Dempsey left Dempsey's Den the show was renamed The Den, with a new presenter, Ray D'Arcy. D'Arcy presented the show from 1990 to 1997 when the strand began to expand it schedule into the early hours of the morning. From 1997 to 2010 The Den ran for 10 hours a day starting at 07:00 to 17:00 followed by a strand which was given various titles and targeted at a teenage audience. When RTÉ rebranded their children's strands in 2010, this effectively axed the country's longest-running children's TV show.
Saturday programming came from RTÉ Cork in form the mid-1990s to the late-2000s, starting with The Swamp which took the place of classic Irish children's TV such as Pajo's Junkbox, Scratch Saturday and Anything Goes (which broadcast on RTÉ One). Satitude was RTÉ Cork's main TV show for children and was broadcast on The Den on RTÉ2 on Saturday mornings. Satitude was cancelled in 2009.
Den Tots was The Den's pre-school strand. It is replaced by RTÉjr; RTÉ do not advertise during these selected hours.
Teenage television
Shows for young people in the 1970s and 1980s included:
MT USA, a pop video music programming presented from New York by pioneering Irish radio DJ and television presenter Vincent Hanley
Youthline, a series which looked at new and upcoming artists such as U2
In the late 1980s, RTÉ began simulcasting The Beatbox with 2FM as a replacement for MT USA. Presenters included Barry Lang, Electric Eddie (Doug Murray), Simon Young, Peter Collins, Ian Dempsey. It was replaced in 1995 with Dave Fanning's 2TV. 2TV spawned several spin offs: late night videos hosted by Jon Slattery, and RTÉ's only attempt at a morning show in 1999 with Bianka Luykx.
In 1988, Jo Maxi appeared for the first time until 1993, a daily teen show airing at 18:00, which was later replaced by Echo Island and in the early 2000s by ID, followed by ID2, TTV and Two Tube. Within the programming block, contained such shows as The Big Bang Theory, Neighbours (repeated from RTÉ One), The Simpsons and Home and Away. This block of programming finished in 2016.
Space Station Video's – Late 1985/1986 – music video show presented by people from the world of music, sport & entertainment, including chris de burgh & phil lynnot – Set on a space station – time on – unknown.
News and current affairs
Since January 2017 RTÉ2 provides no regular prime time news or current affairs programme. Children's news programme News2day remains part of their line up, however this programme only airs until the end of May, with it finishing up in Mid-March in 2020 due to the Covid Crisis.
From 1978 to 2014, RTÉ2 provided late night news. The first such news programme was called NewsNight. The programme was a wide international news service which provided news stories from US and UK broadcasters the show also included a national news bulletin, the final late night news on the channel was called RTÉ News on Two.
As part of the relaunch of RTÉ Two as Network 2 in 1988 the news was renamed Network News. The news was now similar in style to the newly launched Six One news and Nine News on RTÉ One.
In 1997, with the possibility of competition from a new local broadcaster Network 2 relaunch again known on screen as N2. Late night news was renamed News2 and was hosted by Sharon Ní Bheoláin and Anthony Murnane and aimed at a much younger audience. Its content was customised for a younger audience, and presenters and journalists tend to use more informal language on the programme.
In 2004 following another relaunch back to the name of back to RTÉ TWO, the programme was renamed RTÉ News on Two. It was the final RTÉ late evening news programme to air on the channel. The program was broadcast Monday-Thursday. It did not have a regular time slot, but was usually broadcast at some point between 22:45 and 23:30. In October 2006 Eileen Whelan became the main presenter for the programme, following the departure of Anthony Murnane who was with the programme since 1997. John O'Driscoll was the programme Editor. When RTÉ launched their mid-breakfast programme, Morning Edition, on RTÉ One RTÉ News on Two was reduced to a 10-minute bulletin, until its demise in 2014.
In March 2007 until September 2014 it was available as streamed live on the RTÉ website. On Fridays an extended late summary on RTÉ One was broadcast instead of RTÉ News on Two.
On 22 September 2014 it was dropped in favour of two bulletins at 18:55 and 19:55 called News Feed, it was cancelled in January 2017.
RTÉ2 no longer cover current affairs. Current affairs programming on the channel included Market Place a business news show and Later on 2. On Budget Day, RTÉ broadcast Opposition speeches on RTÉ2, while both RTÉ One and RTÉ News Now covered analysis of the budget. In 2018 due to an Irish Soccer match on the same night the Budget speeches moved to the RTÉ News channel, where they have since remained.
Sport
In 2019 it was announced that RTÉ planned to move all major sporting events to RTÉ One.
RTÉ2 broadcasts the majority of RTÉ's sports content. Since RTÉ own rights to several competitions any fixtures clashing with RTÉ2's schedule will often be provided on RTÉ One, however RTÉ One rarely provides sporting events on weekdays hence most soccer matches are shown on RTÉ2. These include UEFA Champions league and the League of Ireland and competitive Ireland National Football Team matches. George Hamilton is the station's main sports commentator. RTÉ2 also covers some smaller sports such as athletics, cycling, extreme sports, golf, field hockey, racquet sports, scuba diving, target shooting, triathlon, and water sports. RTÉ2 also covers the Olympic Games.
RTÉ used to cover basketball which has moved to TG4, combat sports, snooker, pool and used to cover the annual International Rules Series between Ireland and Australia; however, this has moved to TG4. RTÉ also used to cover Wimbledon and the Tour de France which is now on TG4.
RTÉ main sporting rights are UEFA Champions League Live & Highlights, Ireland International qualifying matches Live & Highlights, League of Ireland Live & Highlights, FIFA World Cup Live & Highlights, European Championship Live & Highlights, FAI Cup Live & Highlights, Women's FAI Cup Live & Highlights, 6 Nations Championship Live & Highlights, Ireland Autumn Internationals Live & Highlights, Women's 6 Nations Live & Highlights, Olympic Games, GAA Championship Live & Highlights, GAA League Highlights, Grand National, The Derby, Galway Races, Punchentown and the Cheltenham Festival which take commentary and coverage from Channel 4 with RTÉ's own presenter and analysis.
RTÉ2's sports coverage is its most popular programming strand, it often tops RTÉ2's most watch shows, significantly out doing other all other programming. RTÉ plan to provide most sporting events in High Definition on RTÉ2.
GAA
RTÉ2 provides most of the GAA championship coverage for hurling and football, in 2008, RTÉ lost its monopoly on the championship games to TV3 for the first time in its 10-year history took an interest in the games having mainly bought in soccer and bought live rights for 10 of the matches for three seasons, this forced the Sunday Game Live off air some weekends with live coverage only on TV3 however TV3 lost these rights to Sky Sports for Summer 2014 therefore Sky have 14 live exclusive matches and share semi-finals and finals of the All Ireland Series with RTÉ, RTÉ continue to show the Sunday Game at 9:30 pm on RTÉ2 throughout these month.
The main GAA show is called The Sunday Game it is a review of the weekend's action and it is presented by Michael Lyster and Des Cahill, The Sunday Game Live is broadcast earlier in the day. While The Saturday Game Live only provides live coverage of the games. Setanta Sports also holds rights for the GAA Championships however these are delayed rights as Setanta Sports is a pay television service. RTÉ2 also provides live coverage of the Camogie All-Ireland finals. RTÉ was one of three sponsors for the Hurling Championships.
Soccer
League of Ireland rights are owned by RTÉ and eir Sport. They each take turns on showing live matches each Friday night. RTÉ also show FAI Cup games and the final in HD. Every Monday at 7 pm, RTÉ produce a domestic soccer show called Monday Night Soccer (MNS) presented by Peter Collins which provides a roundup of the weekend of League of Ireland and international team news with regular guests, this was axed in 2014 and replaced by Soccer Republic which airs around 11 pm every Monday night. RTÉ have held rights to the 15:00 Premier League match from the English league between 2004 and 2007, this was hosted by Bill O'Herlihy, Darragh Maloney, Michael Lyster and Des Cahill with commentary by George Hamilton, Peter Collins and Darragh Maloney, however these are now owned by Setanta Sports. In June 2013, RTÉ decided not to renew their highlights package for the Premier League as part of cost-cutting measures and to concentrate on national sporting interests and live sporting rights. This package has been since taken up by eir Sport. The currently have the rights to the 2016 UEFA European championship and 2018 FIFA World Cup. They currently hold the rights to Wednesday nights soccer from the UEFA Champions League with both Setanta and TV3 all other hold rights and signed a new deal in December 2014 to continue broadcasting Champions League to 2018. They also broadcast games of the Republic of Ireland national football team competitive matches in qualifying for European Championships and World Cups and matches in these tournaments should they qualify, though the games were formerly broadcast by RTÉ One. After successfully broadcasting the men's tournament a year ago, in 2019 RTÉ also aired the FIFA Women's World Cup with TG4. RTÉ broadcasts 23 of 52 matches in English and TG4 with 29 of 52 matches in Irish respectively. The presenter for big matches such as the Champions League and Ireland matches is Darragh Maloney who is usually joined by Eamonn Dunphy, John Giles and Liam Brady while commentary comes from George Hamilton and Jim Beglin or Ray Houghton. Other pundits used by RTÉ are Kenny Cunningham, Richie Sadlier and Ronnie Whelan. Other commentators are Adrian Eames, Stephen Alkin and Peter Collins.
Men's and Women's World Cup coverage
RTÉ have had exclusive rights to the World Cup tournament; coverage is on RTÉ2 while rte.ie provides coverage of clashing games. Having been the only national service until the arrival of TG4 and TV3 in the mid-1990s. In 1990 RTÉ made a major investment into the coverage of the tournament which coincided with Ireland's successful campaign under the management of Jack Charlton. The main panel of pundits appeared for the first time consisting of presenter Bill O'Herlihy and pundits John Giles and Eamon Dunphy. For their coverage of 1998 World Cup, RTÉ introduced the comedy Apres Match, a mock of the panel of pundits. The Apres Match pundits first appeared on RTÉ's late night comedy show The End with Barry Murphy. In 1998 the Apres Match pundits for the first time took control of the punditry of the third place play-off and in 2006 surprised themselves and audiences when Barry Murphy playing the part of Liam Brady accurately guess the result – Germany 3 and Portugal 1. In 2006 RTÉ also introduced Graeme Souness as a panellist. Other panellists include Ronnie Whelan, Richie Sadlier, Liam Brady and Denis Irwin. In 2010 Ossie Ardiles, Dietmar (Didi) Hamann and Kevin Kilbane joined the team of panellists. Darragh Maloney, Peter Collins and Con Murphy also present live matches and highlights of the games each night. The matches commentary is provided by George Hamilton, Ray Houghton, Gabriel Egan, Trevor Steven, Stephen Alkin, Damian Richardson, Adrian Eames, Matt Holland and Jimmy Magee.
2014 was Bill O'Herlihy's final World Cup for RTÉ and he has been replaced by Darragh Maloney who was number 2 during the World Cup. Guest pundits used for the World Cup in 2014 were Ossie Ardilles, Didi Hamann, Neil Lennon, Brad Friedel, Paul Clement and Michael O'Neill alongside the existing RTÉ Team of Dunphy, Brady, Giles, Sadlier, Cunningham and Whelan. Commentators were George Hamilton, Stephen Alkin, Peter Collins and Adrian Eames while co-commentators were Ray Houghton, Jim Beglin, Trevor Steven and Brian Kerr.
Rugby
RTÉ currently holds the rights to the RBS Six Nations Championship until 2017. They previously held the rights to all Ireland games in the tournament until 1998, when BSkyB had the rights to home England games until 2003. Since 2003 the tournament has been broadcast in its entirety live on RTÉ2, since 2010 RTÉ have been host broadcaster for Ireland home games. Ireland's Autumn International Series is also broadcast live on RTÉ, with the station holding the rights until 2017.
RTÉ had shown every Rugby World Cup until 2007 when Setanta Ireland secured the full rights to the 2007 and 2011 editions. With Ireland games at the tournament an A listed event, terrestrial rights went to TV3 for the 2007 edition, the 2011 tournament returned to RTÉ with the station broadcasting 11 games live, including the opening match, all Ireland's games and every game from the quarter finals on. RTÉ and Setanta Sports lost the rights to RWC in 2015 to TV3.
The Heineken Cup was broadcast live on RTÉ from its inception until 2006. In 2006, BSkyB secured the exclusive Irish broadcast rights, highlights remained on RTÉ until the 2011/12 season when TG4 obtained the highlights package in a three-year deal. The Rabo Direct Pro 12 has been broadcast on RTÉ since 2010, previously coverage was on TG4 and Setanta Ireland. Ireland continues to cover Ireland Autumn Internationals signing a deal alongside Sky Sports from 2014 to 2018, Sky replaced BBC as the Nationwide broadcaster for Irish Autumn Internationals.
RTÉ presenter for Rugby is Tom McGurk who usually hosts alongside George Hook, Brent Pope and Conor O'Shea. Other presenters used by RTÉ are Joanne Cantwell and Daire O'Briain while other pundits include Shane Horgan, Ronan O'Gara, Alan Quinlan, Frankie Sheahan, Bernard Jackman, Scott Hastings and Ben Kay. RTÉ's main commentator is Ryle Nugent while George Hamilton and Hugh Cahill also work on the 6 Nations. Co-commentators include Donal Lenihan, Ralph Keyes and Tony Ward.
Entertainment
RTÉ2's entertainment content is generally aimed at a young audience to that of its sister channel RTÉ One. Since 1988 RTÉ2 has been successful with a number of entertainment shows aimed at the 15- to 35-year-old age group.
In the early years of RTÉ2 music shows on the channel consisted of Music TV USA every Friday night, which was then repeated on Sunday afternoons at 3 pm. In the mid-1980s this was replaced by The Beatbox presented by Ian Dempsey. From 1995, Dave Fanning presented a near identical programme under the new name of 2TV. The Beatbox and 2TV were both broadcast on 2FM RTÉ's popular music radio station.
No Disco was an alternative music show for late night TV from 1993 to 2003, it was hosted by initially by Donal Dineen who left to present radio on Radio Ireland in 1997. Uaneen Fitzsimons took his place on the show, seen as a major upcoming television talent. Fitzsimons died in a road accident in 2000. She had made a significant name for herself on the show, and her knowledge of the music industry, her love of the music and her respect for her guests was apparent throughout the show.
When Under Ether is a music magazine show launched in 2009 and focuses on alternative, indie and electronica music.
In 1997, Later on 2, aired on Tuesday nights, was the arts review show presented by John Kelly who now presents a similar show on RTÉ One called The View. Also in 1997, RTÉ introduced a set of comedy television shows on the newly re-launched N2 service. Don't Feed The Gondolas or DFTG was presented by Sean Moncreiff and later by Brendan O'Connor. In the initial years Brendan O'Connor was one of the main team captains, during the final season Brendan O'Connor became the main host with only three guests. Other shows to begin that year included Rodge and Podge: A Scare at Bedtime and @LastTV, a fast-paced review show with interviews, comedy sketches and music.
In 2009, RTÉ2 revamped its entertainment season with critics and fans still undecided about new titles which included The Byrne Ultimatum, Maeve Higgins' Fancy Vittles, The Republic of Telly and Podge & Rodge's Stickit Inn.
Cláracha Gaeilge
As part of RTÉ Two's re-brand to Network 2 some emphasises was put on Irish language programming including a daily current affairs show called Cursaí. The series ran from 1988 to 1996 at 19:00 Monday to Friday. The series was later moved around both RTÉ channels. RTÉ retained the arts spin-off programme, Cursaí Ealaíona, into the late 1990s on RTÉ One. RTÉ also broadcast a daily news service in Irish at 20:00 each night, this later moved to RTÉ One.
RTÉ provides Irish language children's programming on both RTÉjr and TRTÉ, much of its Irish language programming has moved to either RTÉ One or TG4. In the early 1990s RTÉ suggested using RTÉ Two's evening schedule for Irish Language programming, rather than starting a new service.
Other Irish language programming on RTÉ Two included school's quiz Eureka and light entertainment show Seán Bán in a Shuí.
References in media
Saturday Night Live has mentioned this station on two occasions:
The recurring sketch "Top O'The Morning" hosted by two barflies Patrick Fitzwilliam (Jimmy Fallon) and William Fitzpatrick (Seth Meyers) is said to have broadcast on RTÉ2.
A one-off sketch parodying reality shows that focus on remodelling houses called "You Call This A House, Do Ya?" is also said to have broadcast on RTÉ2.
See also
List of programmes broadcast by Telefís Éireann
RTÉ One
References
External links
RTÉ2
2
Television channels and stations established in 1978
1978 establishments in Ireland
|
```go
//+build special
package main
import "fmt"
func otherFunc() {
fmt.Printf("special build\n")
}
```
|
```objective-c
// StreamUtils.h
#ifndef __STREAM_UTILS_H
#define __STREAM_UTILS_H
#include "../IStream.h"
HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *size) throw();
HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size) throw();
HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size) throw();
HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size) throw();
#endif
```
|
```java
package home.smart.fly.animations.ui;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.skydoves.transformationlayout.TransformationLayout;
import com.skydoves.transformationlayout.TransitionExtensionKt;
/**
* @author Rookie
* @since 03-03-2020
*
* TransformationLayout
*/
public class SimpleBaseActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
TransformationLayout.Params params = getIntent().getParcelableExtra("TransformationParams");
TransitionExtensionKt.onTransformationEndContainer(this, params);
super.onCreate(savedInstanceState);
}
}
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.