text stringlengths 1 1.05M |
|---|
; A133934: A007318 * (a diagonalized version of A124625).
; Submitted by Christian Krause
; 1,1,2,1,4,1,1,6,3,4,1,8,6,16,1,1,10,10,40,5,6,1,12,15,80,15,36,1,1,14,21,140,35,126,7,8,1,16,28,224,70,336,28,64,1,1,18,36,336,126,756,84,288,9,10
lpb $0
add $1,1
sub $0,$1
lpe
bin $1,$0
mov $2,$0
mod $2,2
mul $2,$1
mul $2,$0
add $2,$1
mov $0,$2
|
/*
* CScaler.cpp
*
* Created on: 01.10.2011
* Author: gerstrong
*/
#include "CScaler.h"
#include "scalebit.h"
#include <graphics/GsSurface.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
/**
* Setters
*/
/*void CScaler::setDynamicFactor( const float wFac, const float hFac)
{
this->hFac = hFac;
this->wFac = wFac;
}
void CScaler::setFilterFactor( const Uint32 FilterFactor )
{
this->FilterFactor = FilterFactor;
}
void CScaler::setFilterType( bool IsNormal )
{
this->IsFilterNormal = IsNormal;
}*/
/**
* Scale functions
*/
void scaleDynamic( SDL_Surface *srcSfc,
SDL_Rect srGsRect,
SDL_Surface *dstSfc,
SDL_Rect dstRect )
{
const bool equalWidth = (dstRect.w == srcSfc->w);
const bool equalHeight = (dstRect.h == srcSfc->h);
GsWeakSurface sfcSfcWeak(srcSfc);
GsWeakSurface dstSfcWeak(dstSfc);
if(equalWidth && equalHeight)
{
SDL_Rect sdldstrect;
sdldstrect.x = dstRect.x; sdldstrect.y = dstRect.y;
sdldstrect.w = dstRect.w; sdldstrect.h = dstRect.h;
assert(srcSfc);
assert(dstSfc);
sfcSfcWeak.blitTo(dstSfcWeak, srGsRect, sdldstrect);
return;
}
SDL_LockSurface( srcSfc );
SDL_LockSurface( dstSfc );
Uint32 *dstFirstPixel = static_cast<Uint32*>(dstSfc->pixels);
Uint32 *srcFirstPixel = static_cast<Uint32*>(srcSfc->pixels);
Uint32 *dstPixel = dstFirstPixel;
Uint32 *srcPixel = srcFirstPixel;
// Pass those numbers to the stack, they are used very often.
const float wFac = (float(srcSfc->w)) / (float(dstRect.w));
const float hFac = (float(srcSfc->h)) / (float(dstRect.h));
int pitch = dstRect.y*dstSfc->w;
if(pitch >= 0)
{
dstPixel += pitch;
}
if(dstRect.x >= 0)
{
dstPixel += dstRect.x;
}
if(dstRect.w > dstSfc->w)
{
dstRect.w = dstSfc->w;
}
if(dstRect.h > dstSfc->h)
{
dstRect.h = dstSfc->h;
}
float xSrc, ySrc;
ySrc = 0.0f;
if(equalWidth)
{
for( int yDst = 0 ; yDst<dstSfc->h ; yDst++ )
{
const Uint32 posY = (yDst*srcSfc->h)/dstSfc->h;
memcpy(dstPixel, srcPixel+(posY*dstSfc->w), srcSfc->pitch);
dstPixel += dstSfc->w;
}
}
else
{
for( int yDst = 0 ; yDst<dstRect.h ; yDst++ )
{
xSrc = 0.0f;
pitch = Uint32(ySrc)*srcSfc->w;
for( int xDst = 0; xDst<dstRect.w ; xDst++ )
{
*dstPixel = srcPixel[pitch+Uint32(xSrc)];
xSrc += wFac;
dstPixel++;
}
ySrc += hFac;
dstPixel = dstFirstPixel + (dstSfc->w*yDst);
}
}
SDL_UnlockSurface( dstSfc );
SDL_UnlockSurface( srcSfc );
}
void scaleNormal( SDL_Surface *srcSfc,
SDL_Surface *dstSfc,
const Uint32 filterFac)
{
if( (dstSfc->w == srcSfc->w) && (dstSfc->h == srcSfc->h) )
{
assert(srcSfc);
assert(dstSfc);
GsWeakSurface srcSfcWeak(srcSfc);
GsWeakSurface dstSfcWeak(dstSfc);
srcSfcWeak.blitTo(dstSfcWeak);
return;
}
const Uint32 srcWidth = Uint32(srcSfc->w);
const Uint32 srcHeight = Uint32(srcSfc->h);
const Uint32 dstWidth = Uint32(dstSfc->w);
const Uint16 dstPitch = dstSfc->pitch;
Uint32 *dstPixel = static_cast<Uint32*>(dstSfc->pixels);
Uint32 *origDstPixel = dstPixel;
Uint32 *srcPixel = static_cast<Uint32*>(srcSfc->pixels);
Uint32 zoomIndex;
for( Uint32 ySrc = 0, xSrc ; ySrc<srcHeight ; ySrc++ )
{
// First we just stretch a row horizontally
for( xSrc = 0 ; xSrc<srcWidth ; xSrc++, srcPixel++ )
for( zoomIndex = 0; zoomIndex < filterFac; zoomIndex++, dstPixel++ )
*dstPixel = *srcPixel;
// Maybe a POT surface is used
dstPixel+=dstWidth-(dstPixel-origDstPixel);
// Now we make copies of the stretched row
for( zoomIndex = 1; zoomIndex < filterFac; zoomIndex++, dstPixel+=dstWidth )
memcpy(dstPixel, origDstPixel, dstPitch);
origDstPixel += zoomIndex*dstWidth;
}
}
int sFiltToNum(const VidFilter filt)
{
return static_cast<int>(filt);
}
void blitScaled(SDL_Surface *srcSfc,
SDL_Rect &srGsRect,
SDL_Surface *dstSfc,
SDL_Rect &dstRect,
const VidFilter filter)
{
// First phase: Filter the surface (scaleX)
SDL_Rect lSrGsRect = srGsRect;
SDL_Rect lDstRect = dstRect;
auto iFilter = int(filter);
// Find the best filter for the current resolution
while( iFilter > 1 )
{
// Does it fit?
if( dstSfc->w >= srcSfc->w*iFilter &&
dstSfc->h >= srcSfc->h*iFilter )
{
break;
}
iFilter--;
}
// If there is a chance to scale through filter, do so.
if( iFilter>1 )
{
SDL_LockSurface( srcSfc );
SDL_LockSurface( dstSfc );
scale( iFilter,
dstSfc->pixels,
dstSfc->pitch,
srcSfc->pixels,
srcSfc->pitch,
dstSfc->format->BytesPerPixel,
srcSfc->w,
srcSfc->h );
SDL_UnlockSurface( dstSfc );
SDL_UnlockSurface( srcSfc );
lSrGsRect.w = lSrGsRect.w*iFilter;
lSrGsRect.h = lSrGsRect.h*iFilter;
}
else
{
// Second phase: Scale it normally
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_BlitScaled( srcSfc, &lSrGsRect, dstSfc, &lDstRect );
#else
scaleDynamic( srcSfc, lSrGsRect, dstSfc, lDstRect );
//scaleNormal(srcSfc, dstSfc, (Uint32)SCALE_4X );
#endif
}
}
|
/* +------------------------------------------------------------------------+
| Mobile Robot Programming Toolkit (MRPT) |
| https://www.mrpt.org/ |
| |
| Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
| See: https://www.mrpt.org/Authors - All rights reserved. |
| Released under BSD License. See: https://www.mrpt.org/License |
+------------------------------------------------------------------------+ */
#include "hwdrivers-precomp.h" // Precompiled headers
#include <mrpt/config/CConfigFilePrefixer.h>
#include <mrpt/hwdrivers/CGPS_NTRIP.h>
#include <iostream>
using namespace mrpt::hwdrivers;
using namespace mrpt::obs;
using namespace mrpt::system;
using namespace std;
IMPLEMENTS_GENERIC_SENSOR(CGPS_NTRIP, mrpt::hwdrivers)
/** Constructor. See mrpt::hwdrivers::CGPSInterface for the meaning of params.
*/
CGPS_NTRIP::CGPS_NTRIP() : gps(), ntrip() {}
/** Destructor */
CGPS_NTRIP::~CGPS_NTRIP() = default;
void CGPS_NTRIP::initialize()
{
gps.initialize();
ntrip.initialize();
}
// See docs in parent class
void CGPS_NTRIP::doProcess()
{
// Process GPS:
gps.doProcess();
// Move sensed observations to this object:
{
TListObservations lst;
gps.getObservations(lst);
std::vector<mrpt::serialization::CSerializable::Ptr> vect;
vect.reserve(lst.size());
for (auto it = lst.begin(); it != lst.end(); ++it)
vect.push_back(it->second);
this->appendObservations(vect);
}
// New GGA frames?
std::string sLastGGA = gps.getLastGGA();
if (!sLastGGA.empty())
{
if (m_verbose)
cout << "[CGPS_NTRIP] Redirecting GGA frame from GPS->NTRIP: '"
<< sLastGGA << "'" << endl;
ntrip.getNTRIPClient().sendBackToServer(sLastGGA + std::string("\r\n"));
}
// Process NTRIP server comms:
ntrip.doProcess();
}
void CGPS_NTRIP::loadConfig_sensorSpecific(
const mrpt::config::CConfigFileBase& cfg, const std::string& section)
{
// Load GPS params:
gps.loadConfig(mrpt::config::CConfigFilePrefixer(cfg, "", "gps_"), section);
// NTRIP params:
ntrip.loadConfig(
mrpt::config::CConfigFilePrefixer(cfg, "", "ntrip_"), section);
// Own params:
// (none yet)
}
|
; A078607: Least positive integer x such that 2*x^n > (x+1)^n.
; 1,2,3,4,6,7,9,10,12,13,14,16,17,19,20,22,23,25,26,27,29,30,32,33,35,36,38,39,40,42,43,45,46,48,49,50,52,53,55,56,58,59,61,62,63,65,66,68,69,71,72,74,75,76,78,79,81,82,84,85,87,88,89,91,92,94,95,97,98,100,101,102
mov $11,$0
sub $0,1
mul $0,4
mov $5,2
mov $8,1
add $8,$0
lpb $0,1
sub $0,$5
add $0,$8
div $0,10
sub $8,1
clr $5,2
lpe
add $0,1
mov $1,$0
add $1,$11
|
.global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r14
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0x1302b, %rsi
lea addresses_WT_ht+0xe75c, %rdi
nop
nop
nop
nop
sub $28716, %rdx
mov $99, %rcx
rep movsw
sub %rdi, %rdi
lea addresses_D_ht+0x8ca7, %rdx
clflush (%rdx)
xor %r13, %r13
vmovups (%rdx), %ymm4
vextracti128 $1, %ymm4, %xmm4
vpextrq $0, %xmm4, %r14
nop
nop
nop
nop
nop
xor %rsi, %rsi
lea addresses_UC_ht+0x5e8b, %rsi
lea addresses_normal_ht+0x1694b, %rdi
dec %r13
mov $75, %rcx
rep movsb
nop
nop
xor %r14, %r14
lea addresses_WC_ht+0x35cb, %rdi
cmp $49072, %rcx
mov $0x6162636465666768, %r13
movq %r13, %xmm7
and $0xffffffffffffffc0, %rdi
movntdq %xmm7, (%rdi)
nop
nop
xor %rdi, %rdi
lea addresses_D_ht+0xf73b, %rcx
nop
nop
nop
and $36367, %rbx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm5
vmovups %ymm5, (%rcx)
nop
nop
inc %r13
lea addresses_D_ht+0x1d54b, %rdx
nop
nop
nop
nop
and $36863, %rsi
mov (%rdx), %r13
nop
sub %rcx, %rcx
lea addresses_normal_ht+0x17977, %rdi
nop
nop
inc %rbx
mov (%rdi), %r14d
nop
nop
xor %r13, %r13
lea addresses_WT_ht+0xfef, %rsi
lea addresses_WT_ht+0x16a53, %rdi
nop
nop
nop
nop
add $54610, %r14
mov $68, %rcx
rep movsl
cmp $41510, %rsi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r14
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r14
push %r8
push %rbp
push %rdi
push %rdx
push %rsi
// Store
lea addresses_PSE+0x1154b, %rdx
inc %rdi
mov $0x5152535455565758, %r11
movq %r11, %xmm0
vmovups %ymm0, (%rdx)
cmp %r14, %r14
// Faulty Load
lea addresses_PSE+0x1154b, %rbp
nop
nop
nop
nop
nop
sub $59204, %r8
mov (%rbp), %edx
lea oracles, %r11
and $0xff, %rdx
shlq $12, %rdx
mov (%r11,%rdx,1), %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rbp
pop %r8
pop %r14
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'AVXalign': False, 'congruent': 0, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_PSE', 'AVXalign': False, 'congruent': 0, 'size': 32, 'same': True, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'AVXalign': False, 'congruent': 0, 'size': 4, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 0, 'size': 32, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 10, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 7, 'size': 16, 'same': False, 'NT': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 4, 'size': 32, 'same': True, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 11, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 2, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 2, 'same': False}}
{'58': 21829}
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
|
#ifndef CPU_H
#define CPU_H
#include <vector>
#include "const.hpp"
#include "ram.hpp"
using namespace std;
class Instruction;
class Cpu {
public:
Cpu(Ram &ramIn) : ram(ramIn) { }
bool step();
void reset();
Instruction getInstruction() const;
vector<bool> getRegister() const;
vector<bool> getPc() const;
int getCycle() const;
void switchOn();
private:
Ram &ram;
vector<bool> reg = vector<bool>(WORD_SIZE);
vector<bool> pc = vector<bool>(ADDR_SIZE);
int cycle = 0;
};
#endif
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r15
push %r9
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x18094, %r15
nop
nop
nop
sub %r11, %r11
movb (%r15), %cl
sub %rdx, %rdx
lea addresses_WT_ht+0x1cb94, %rbp
nop
nop
nop
cmp %r10, %r10
mov $0x6162636465666768, %r9
movq %r9, %xmm2
and $0xffffffffffffffc0, %rbp
movaps %xmm2, (%rbp)
nop
nop
inc %r9
lea addresses_UC_ht+0x8d74, %rsi
lea addresses_UC_ht+0x9c34, %rdi
inc %r15
mov $16, %rcx
rep movsq
nop
nop
nop
nop
and %rdx, %rdx
lea addresses_normal_ht+0x7fc4, %r9
nop
sub %rsi, %rsi
mov (%r9), %rcx
nop
nop
nop
nop
xor $31895, %rsi
lea addresses_D_ht+0x1d06c, %rsi
lea addresses_A_ht+0x3214, %rdi
nop
nop
nop
nop
cmp $13978, %r10
mov $4, %rcx
rep movsq
nop
nop
xor %rcx, %rcx
lea addresses_WT_ht+0x15654, %rdi
cmp %rcx, %rcx
mov (%rdi), %dx
nop
nop
nop
nop
sub %rbp, %rbp
lea addresses_UC_ht+0x1a9e4, %rsi
lea addresses_A_ht+0x8f84, %rdi
nop
nop
nop
xor $50146, %r10
mov $88, %rcx
rep movsb
nop
nop
nop
nop
nop
xor $43492, %rbp
lea addresses_A_ht+0xc814, %rsi
lea addresses_WC_ht+0x17894, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
inc %rbp
mov $93, %rcx
rep movsl
cmp %r15, %r15
lea addresses_WC_ht+0x15894, %r10
nop
cmp $1069, %rcx
mov $0x6162636465666768, %r9
movq %r9, %xmm1
vmovups %ymm1, (%r10)
nop
nop
nop
sub $33966, %r9
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r15
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %rax
push %rbx
push %rsi
// Faulty Load
lea addresses_A+0x1a094, %r10
nop
nop
nop
nop
nop
sub %rbx, %rbx
movb (%r10), %al
lea oracles, %r10
and $0xff, %rax
shlq $12, %rax
mov (%r10,%rax,1), %rax
pop %rsi
pop %rbx
pop %rax
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0, 'same': False, 'type': 'addresses_A'}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0, 'same': True, 'type': 'addresses_A'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 9, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': True, 'size': 16, 'congruent': 6, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'STOR'}
{'src': {'congruent': 3, 'same': False, 'type': 'addresses_UC_ht'}, 'dst': {'congruent': 0, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'REPM'}
{'src': {'NT': True, 'AVXalign': True, 'size': 8, 'congruent': 4, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 3, 'same': False, 'type': 'addresses_D_ht'}, 'dst': {'congruent': 7, 'same': True, 'type': 'addresses_A_ht'}, 'OP': 'REPM'}
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 5, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 4, 'same': True, 'type': 'addresses_UC_ht'}, 'dst': {'congruent': 4, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'REPM'}
{'src': {'congruent': 7, 'same': False, 'type': 'addresses_A_ht'}, 'dst': {'congruent': 8, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 11, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'STOR'}
{'00': 1, '35': 21828}
00 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35
*/
|
;
; Copyright (c) 2010 The WebM project authors. All Rights Reserved.
;
; Use of this source code is governed by a BSD-style license
; that can be found in the LICENSE file in the root of the source
; tree. An additional intellectual property rights grant can be found
; in the file PATENTS. All contributing project authors may
; be found in the AUTHORS file in the root of the source tree.
;
EXPORT |vp8_fast_fdct8x4_neon|
ARM
REQUIRE8
PRESERVE8
AREA ||.text||, CODE, READONLY, ALIGN=2
;void vp8_fast_fdct4x4_c(short *input, short *output, int pitch);
;NOTE:
;The input *src_diff. src_diff is calculated as:
;diff_ptr[c] = src_ptr[c] - pred_ptr[c]; (in Subtract* function)
;In which *src_ptr and *pred_ptr both are unsigned char.
;Therefore, *src_diff should be in the range of [-255, 255].
;CAUTION:
;The input values of 25th block are set in vp8_build_dcblock function, which are out of [-255, 255].
;But, VP8 encoder only uses vp8_short_fdct4x4_c for 25th block, not vp8_fast_fdct4x4_c. That makes
;it ok for assuming *input in [-255, 255] in vp8_fast_fdct4x4_c, but not ok in vp8_short_fdct4x4_c.
|vp8_fast_fdct8x4_neon| PROC
vld1.16 {q1}, [r0], r2 ;load input
ldr r12, _ffdct8_coeff_
vld1.16 {q2}, [r0], r2
vld1.16 {q3}, [r0], r2
vld1.16 {d0}, [r12]
vld1.16 {q4}, [r0], r2
;First for-loop
;transpose d2, d4, d6, d8. Then, d2=ip[0], d4=ip[1], d6=ip[2], d8=ip[3]
;transpose d3, d5, d7, d9. Then, d3=ip[0], d5=ip[1], d7=ip[2], d9=ip[3]
vtrn.32 d2, d6
vtrn.32 d3, d7
vtrn.32 d4, d8
vtrn.32 d5, d9
vtrn.16 d2, d4
vtrn.16 d3, d5
vtrn.16 d6, d8
vtrn.16 d7, d9
vadd.s16 d10, d2, d8 ;ip[0]+ip[3]
vadd.s16 d11, d4, d6 ;ip[1]+ip[2]
vsub.s16 d12, d4, d6 ;ip[1]-ip[2]
vsub.s16 d13, d2, d8 ;ip[0]-ip[3]
vadd.s16 d22, d3, d9
vadd.s16 d23, d5, d7
vsub.s16 d24, d5, d7
vsub.s16 d25, d3, d9
vshl.i16 q5, q5, #1 ; a1, b1
vshl.i16 q6, q6, #1 ; c1, d1
vshl.i16 q1, q11, #1
vshl.i16 q2, q12, #1
vadd.s16 d14, d10, d11 ;temp1 = a1 + b1
vsub.s16 d15, d10, d11 ;temp2 = a1 - b1
vadd.s16 d24, d2, d3
vsub.s16 d25, d2, d3
vqdmulh.s16 q8, q7, d0[1]
vqdmulh.s16 q13, q12, d0[1]
vqdmulh.s16 q10, q6, d0[0]
vqdmulh.s16 q15, q2, d0[0]
vqdmulh.s16 q9, q6, d0[2]
vqdmulh.s16 q14, q2, d0[2]
vshr.s16 q8, q8, #1
vshr.s16 q13, q13, #1
vshr.s16 q10, q10, #1
vshr.s16 q15, q15, #1
vshr.s16 q9, q9, #1 ;d18:temp1 = ( c1 * x_c3)>>16; d19:temp1 = (d1 * x_c3)>>16
vshr.s16 q14, q14, #1 ;d28:temp1 = ( c1 * x_c3)>>16; d29:temp1 = (d1 * x_c3)>>16
vadd.s16 q10, q6, q10 ;d20:temp2 = ((c1 * x_c1)>>16) + c1; d21:temp2 = ((d1 * x_c1)>>16) + d1
vadd.s16 q15, q2, q15 ;d30:temp2 = ((c1 * x_c1)>>16) + c1; d31:temp2 = ((d1 * x_c1)>>16) + d1
vadd.s16 d2, d14, d16 ;op[0] = ((temp1 * x_c2 )>>16) + temp1
vadd.s16 d3, d24, d26 ;op[0] = ((temp1 * x_c2 )>>16) + temp1
vadd.s16 d6, d15, d17 ;op[2] = ((temp2 * x_c2 )>>16) + temp2
vadd.s16 d7, d25, d27 ;op[2] = ((temp2 * x_c2 )>>16) + temp2
vadd.s16 d4, d18, d21 ;op[1] = temp1 + temp2 -- q is not necessary, just for protection
vadd.s16 d5, d28, d31 ;op[1] = temp1 + temp2 -- q is not necessary, just for protection
vsub.s16 d8, d19, d20 ;op[3] = temp1 - temp2
vsub.s16 d9, d29, d30 ;op[3] = temp1 - temp2
;Second for-loop
;transpose d2, d4, d6, d8. Then, d2=ip[0], d4=ip[4], d6=ip[8], d8=ip[12]
;transpose d3, d5, d7, d9. Then, d3=ip[0], d5=ip[4], d7=ip[8], d9=ip[12]
vtrn.32 d2, d6
vtrn.32 d3, d7
vtrn.32 d4, d8
vtrn.32 d5, d9
vtrn.16 d2, d4
vtrn.16 d3, d5
vtrn.16 d6, d8
vtrn.16 d7, d9
vadd.s16 d10, d2, d8 ;a1 = ip[0]+ip[12]
vadd.s16 d11, d4, d6 ;b1 = ip[4]+ip[8]
vsub.s16 d12, d4, d6 ;c1 = ip[4]-ip[8]
vsub.s16 d13, d2, d8 ;d1 = ip[0]-ip[12]
vadd.s16 d2, d3, d9
vadd.s16 d4, d5, d7
vsub.s16 d24, d5, d7
vsub.s16 d25, d3, d9
vadd.s16 d14, d10, d11 ;temp1 = a1 + b1
vsub.s16 d15, d10, d11 ;temp2 = a1 - b1
vadd.s16 d22, d2, d4
vsub.s16 d23, d2, d4
vqdmulh.s16 q8, q7, d0[1]
vqdmulh.s16 q13, q11, d0[1]
vqdmulh.s16 q10, q6, d0[0]
vqdmulh.s16 q15, q12, d0[0]
vqdmulh.s16 q9, q6, d0[2]
vqdmulh.s16 q14, q12, d0[2]
vshr.s16 q8, q8, #1
vshr.s16 q13, q13, #1
vshr.s16 q10, q10, #1
vshr.s16 q15, q15, #1
vshr.s16 q9, q9, #1 ;d18:temp1 = ( c1 * x_c3)>>16; d19:temp1 = (d1 * x_c3)>>16
vshr.s16 q14, q14, #1 ;d28:temp1 = ( c1 * x_c3)>>16; d29:temp1 = (d1 * x_c3)>>16
vadd.s16 q10, q6, q10 ;d20:temp2 = ((c1 * x_c1)>>16) + c1; d21:temp2 = ((d1 * x_c1)>>16) + d1
vadd.s16 q15, q12, q15 ;d30:temp2 = ((c1 * x_c1)>>16) + c1; d31:temp2 = ((d1 * x_c1)>>16) + d1
vadd.s16 d2, d14, d16 ;a2 = ((temp1 * x_c2 )>>16) + temp1
vadd.s16 d6, d22, d26 ;a2 = ((temp1 * x_c2 )>>16) + temp1
vadd.s16 d4, d15, d17 ;c2 = ((temp2 * x_c2 )>>16) + temp2
vadd.s16 d8, d23, d27 ;c2 = ((temp2 * x_c2 )>>16) + temp2
vadd.s16 d3, d18, d21 ;b2 = temp1 + temp2 -- q is not necessary, just for protection
vadd.s16 d7, d28, d31 ;b2 = temp1 + temp2 -- q is not necessary, just for protection
vsub.s16 d5, d19, d20 ;d2 = temp1 - temp2
vsub.s16 d9, d29, d30 ;d2 = temp1 - temp2
vclt.s16 q5, q1, #0
vclt.s16 q6, q2, #0
vclt.s16 q7, q3, #0
vclt.s16 q8, q4, #0
vsub.s16 q1, q1, q5
vsub.s16 q2, q2, q6
vsub.s16 q3, q3, q7
vsub.s16 q4, q4, q8
vshr.s16 q1, q1, #1
vshr.s16 q2, q2, #1
vshr.s16 q3, q3, #1
vshr.s16 q4, q4, #1
vst1.16 {q1, q2}, [r1]!
vst1.16 {q3, q4}, [r1]
bx lr
ENDP
;-----------------
AREA fastfdct8x4_dat, DATA, READONLY
;Data section with name data_area is specified. DCD reserves space in memory for 48 data.
;One word each is reserved. Label filter_coeff can be used to access the data.
;Data address: filter_coeff, filter_coeff+4, filter_coeff+8 ...
_ffdct8_coeff_
DCD ffdct8_coeff
ffdct8_coeff
; 60547 = 0xEC83
; 46341 = 0xB505
; 25080 = 0x61F8
DCD 0xB505EC83, 0x000061F8
END
|
charmap "A", 1
SECTION "sec", ROM0[0]
_A_ EQU "A"
db _A_
|
/*************************************************************************
* Name : move.hpp
* Author: zmdsn
* Mail : zmdsn@126.com
* Created Time: 2020年11月18日 星期三 13时47分27秒
*
************************************************************************/
#ifndef __K_RELOCATE__HPP__
#define __K_RELOCATE__HPP__
#include<iostream>
#include "../move/move.hpp"
using namespace std;
class K_RELOCATE:public Move_base{
// (x,y) <==> (u,v)
public:
Move_base* m;
DType load_before_u,load_u_v,load_after_v;
std::vector<int> tasks;
std::vector<int> tasks_inv;
inline bool init_move(){
is_legal= is_legal_move();
if (is_legal){
if (!is_prepared) prepare();
tasks.clear();
tasks_inv.clear();
before_u = R1->route[position1-1];
after_v = R1->route[position1+length1+1];
u = R1->route[position1];
v = R1->route[position1+length1];
up = problem->get_invert(u);
vp = problem->get_invert(v);
for (int i = 0; i <= length1; ++i) {
tasks.push_back(R1->route[position1+i]);
tasks_inv.push_back(
problem->get_invert(R1->route[position1+length1-i]));
}
}
return is_legal;
}
DType get_over_load_different_route() {
DType temp_load = 0;
over_load = 0;
R1->get_loads();
R2->get_loads();
loadi = get_load_u_v();
// cout<<"loadi"<<problem->Capacity<<R1->loads<<R2->loads<<loadi<<endl;
temp_load = R1->loads-load_u_v;
if (temp_load>problem->Capacity) {
feasible = 0;
over_load += temp_load-problem->Capacity;
}
temp_load = R2->loads+load_u_v;
if (temp_load>problem->Capacity) {
feasible = 0;
over_load += temp_load-problem->Capacity;
}
return over_load;
}
DType get_over_load(){
if(!is_legal) return 0;
over_load_changed = 0;
over_load = 0;
feasible = 1;
DType old_over_load = get_old_over_load();
if (R1==R2) {
over_load = old_over_load;
return old_over_load;
}
over_load = get_over_load_different_route();
over_load_changed = over_load - old_over_load;
return over_load;
}
DType get_load_u_v(){
load_u_v = 0;
for (int i=position1; i<=position1+length1; i++) {
load_u_v += problem->get_demand(R1->route[i]);
}
return load_u_v;
}
// inline bool p2_not_be_zero(){
// if(position1==0) { return 0; }
// if(position1+length1+1>=R1->route.size()) { return 0; }
// if(position2==0) { return 0; }
// return 1;
// }
// bool not_be_special() {
// if(R1==R2&&(position2>=position1
// &&position2<=position1+length1+1)) {return 0; }
// return 1;
// }
bool is_legal_move(){
is_legal = position1>0;
is_legal &= position1+length1+1 < R1->route.size();
// is_legal &= length1+1 <= R1->route.size();
is_legal &= (R1==R2) && !(R1==R2&&(position2>=position1
&&position2<=position1+length1+1));
// is_legal &= p2_not_be_zero();
return is_legal;
}
bool is_feasible_different_route(){
return get_over_load()<=0;
}
bool is_feasible(){
if(!is_legal) {
feasible = 0;
over_load = get_old_over_load();
over_load_changed = 0;
// cout<<"ov"<<over_load<<" "<<over_load_changed<<endl;
return 0;
}
feasible = 1;
if(get_over_load()>0) return 0;
return is_feasible_different_route();
}
VType relocate_costs(){
VType cost;
cost = get_delete_k_costs(R1,position1,length1+1);
cost+= get_insert_k_costs(R2,position2,tasks);
return cost;
}
VType relocate_costs_inv(){
VType cost;
cost = get_delete_k_costs(R1,position1,length1+1);
cost+= get_insert_k_costs(R2,position2,tasks_inv);
return cost;
}
VType get_move_costs(){
costs = 0;
over_load = 0;
// init_move();
if(!is_legal) {return 0;}
get_over_load();
VType cost1 = relocate_costs();
VType cost2 = relocate_costs_inv();
if(cost2<cost1){
inv_task_i = 1;
costs = cost2;
} else {
inv_task_i = 0;
costs = cost1;
}
return costs;
}
bool relocate_same_route_move(std::vector<int>& tasks){
if(position1>position2) {
delete_k_task(R1->route,position1,length1+1);
insert_k_task(R1->route,position2,tasks);
} else{
insert_k_task(R1->route,position2,tasks);
delete_k_task(R1->route,position1,length1+1);
}
return 1;
}
bool move(){
// cout<<"*************&*^"<<inv_task_i<<position2<<position1<<length1<<endl;
// show(R1->route);
// show(R2->route);
if(!is_legal) return 0;
if(R1==R2) {
// cout<<"moved***********";
if (inv_task_i) {
relocate_same_route_move(tasks_inv);
} else {
relocate_same_route_move(tasks);
}
} else {
delete_k_task(R1->route,position1,length1+1);
if (inv_task_i) {
insert_k_task(R2->route,position2,tasks_inv);
} else {
insert_k_task(R2->route,position2,tasks);
}
R1->loads -= load_u_v;
R2->loads += load_u_v;
}
R1->get_fitness();
R2->get_fitness();
return 1;
}
K_RELOCATE(){
length1 = 1;
// length1 for two tasks
}
K_RELOCATE(CARP_INDIVIDUAL *_R1,CARP_INDIVIDUAL *_R2,
int _position1, int _position2,int _length1):
Move_base(_R1,_R2,_position1,_position2,_length1,0){
}
K_RELOCATE(CARP_INDIVIDUAL *_R1,CARP_INDIVIDUAL *_R2,
int _position1, int _position2):
Move_base(R1,R2,position1,position2){}
K_RELOCATE(CARP_INDIVIDUAL *_R1,CARP_INDIVIDUAL *_R2):Move_base(R1,R2){}
};
#endif
|
<% from pwnlib.util import lists, packing, fiddling %>
<%page args="string, append_null = True"/>
<%docstring>
Pushes a string onto the stack without using
null bytes or newline characters.
Args:
string (str): The string to push.
append_null (bool): Whether to append a single NULL-byte before pushing.
</%docstring>
<%
if append_null:
string += '\x00'
if not string:
return
if ord(string[-1]) >= 128:
extend = '\xff'
else:
extend = '\x00'
%>
% for word in lists.group(4, string, 'fill', extend)[::-1]:
<%
sign = packing.u32(word, 'little', False)
%>
% if sign == 0:
push 1
dec byte ptr [esp] /* ${repr(word)} */
% elif -128 <= sign < 128:
pushb ${hex(sign)} /* ${repr(word)} */
% elif '\x00' not in word and '\n' not in word:
push ${hex(sign)} /* ${repr(word)} */
% else:
<% a,b = fiddling.xor_pair(word, avoid = '\x00\n') %>
push '${repr(a)[1:-1]}'
xor dword [esp], `${repr(b)[1:-1]}` /* ${repr(word)} */
% endif
% endfor
|
;
; Generic pseudo graphics routines for text-only platforms
; Version for the 2x3 graphics symbols
;
; Written by Stefano Bodrato 19/12/2006
;
;
; Invert pixel at (x,y) coordinate.
;
;
; $Id: xorpixl.asm,v 1.7 2016-07-02 09:01:36 dom Exp $
;
INCLUDE "graphics/grafix.inc"
SECTION code_clib
PUBLIC xorpixel
EXTERN textpixl
EXTERN div3
EXTERN __gfx_coords
EXTERN base_graphics
.xorpixel
ld a,h
cp maxx
ret nc
ld a,l
cp maxy
ret nc ; y0 out of range
dec a
dec a
ld (__gfx_coords),hl
push bc
ld c,a ; y
ld b,h ; x
push bc
ld hl,div3
ld d,0
ld e,c
inc e
adc hl,de
ld a,(hl)
ld c,a ; y/3
srl b ; x/2
ld a,c
ld c,b ; !!
;--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
ld hl,0BCAh
ld b,a ; keep y/3
and a
jr z,r_zero
ld hl,$80a
dec a
jr z,r_zero
ld de,64
.r_loop
add hl,de
dec a
jr nz,r_loop
.r_zero
ld e,c
add hl,de
;--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
ld a,(hl) ; get current symbol from screen
ld e,a ; ..and its copy
push hl ; char address
push bc ; keep y/3
ld hl,textpixl
ld e,0
ld b,64 ; whole symbol table size
.ckmap cp (hl) ; compare symbol with the one in map
jr z,chfound
inc hl
inc e
djnz ckmap
ld e,0
.chfound ld a,e
pop bc ; restore y/3 in b
pop hl ; char address
ex (sp),hl ; save char address <=> restore x,y (y=h, x=l)
ld c,a ; keep the symbol
ld a,l
inc a
inc a
sub b
sub b
sub b ; we get the remainder of y/3
ld l,a
ld a,1 ; the pixel we want to draw
jr z,iszero
bit 0,l
jr nz,is1
add a,a
add a,a
.is1
add a,a
add a,a
.iszero
bit 0,h
jr z,evenrow
add a,a ; move down the bit
.evenrow
xor c
ld hl,textpixl
ld d,0
ld e,a
add hl,de
ld a,(hl)
pop hl
ld (hl),a
pop bc
ret
|
; A115790: 1 - (Floor((n+1)*Pi)-Floor(n*Pi)) mod 2.
; 0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0
sub $0,1
mod $0,7
trn $0,5
mov $1,$0
|
; A119332: Expansion of (1+x)/(1-2x^4).
; 1,1,0,0,2,2,0,0,4,4,0,0,8,8,0,0,16,16,0,0,32,32,0,0,64,64,0,0,128,128,0,0,256,256,0,0,512,512,0,0,1024,1024,0,0,2048,2048,0,0,4096,4096,0,0,8192,8192,0,0,16384,16384,0,0,32768
div $0,-2
dif $0,-2
mov $1,2
pow $1,$0
mov $0,$1
|
#pragma once
#include "config.hpp"
#include <fstream>
#include <string>
#include <memory>
#include <stdexcept>
namespace ORCore
{
// TODO - Could be useful to move into the VFS at some point.
// Also in the future we can have an alternative memory mapped file
// implementation when speed is less important than memory usage.
// This is just mainly a basic starting point.
struct FileBuffer
{
std::unique_ptr<char[]> data;
uint32_t position = 0;
uint32_t size = 0;
void load(std::string filename)
{
std::ifstream dataFile(filename, std::ios_base::ate | std::ios_base::binary);
if (dataFile) {
size = dataFile.tellg();
data = std::make_unique<char[]>(size);
dataFile.seekg(0, std::ios::beg);
dataFile.read(&data[0], size);
dataFile.close();
} else {
throw std::runtime_error("Failed to load file.");
}
}
uint32_t get_pos() {
return position;
}
void set_pos(uint32_t pos) {
position = pos;
}
void set_pos_rel(uint32_t pos) {
position += pos;
}
uint32_t get_size() {
return size;
}
void release()
{
data.reset();
}
};
// Custom FileBuffer based reading.
template<typename T>
T read_type(FileBuffer &fileData)
{
T output;
size_t size = sizeof(T);
char *outPtr = reinterpret_cast<char*>(&output);
char *inPtr = &fileData.data[fileData.position];
for(size_t i = 0; i < size; i++) {
outPtr[i] = inPtr[size-1 - i];
}
fileData.position += size;
return output;
}
template<typename T>
T read_type(FileBuffer &fileData, size_t size)
{
T output = 0;
if (sizeof(output) < size)
{
throw std::runtime_error("Size greater than container type");
} else {
char *outPtr = reinterpret_cast<char*>(&output);
char *inPtr = &fileData.data[fileData.position];
for(size_t i = 0; i < size; i++) {
outPtr[i] = inPtr[size-1 - i];
}
fileData.position += size;
}
return output;
}
// Main purpose is for reading string-like data from the file.
template<typename T>
void read_type(FileBuffer &fileData, T *output, unsigned long length)
{
size_t size = sizeof(T);
char *outPtr = reinterpret_cast<char*>(output);
char *inPtr;
for (size_t j = 0; j < length; j++) {
inPtr = &fileData.data[fileData.position];
for(size_t i = 0; i < size; i++) {
outPtr[i] = inPtr[size-1 - i];
}
outPtr += size;
fileData.position += size;
}
}
template<typename T>
T peek_type(FileBuffer &fileData)
{
T output;
size_t size = sizeof(T);
char *outPtr = reinterpret_cast<char*>(&output);
char *inPtr = &fileData.data[fileData.position];
for(size_t i = 0; i < size; i++) {
outPtr[i] = inPtr[size-1 - i];
}
return output;
}
template<typename T>
T peek_type(FileBuffer &fileData, size_t size)
{
T output = 0;
if (sizeof(output) < size)
{
throw std::runtime_error("Size greater than container type");
} else {
char *outPtr = reinterpret_cast<char*>(&output);
char *inPtr = &fileData.data[fileData.position];
for(size_t i = 0; i < size; i++) {
outPtr[i] = inPtr[size-1 - i];
}
}
return output;
}
// Main purpose is for reading string-like data from the file.
template<typename T>
void peek_type(FileBuffer &fileData, T *output, unsigned long length)
{
size_t size = sizeof(T);
char *outPtr = reinterpret_cast<char*>(output);
char *inPtr;
for (size_t j = 0; j < length; j++) {
inPtr = &fileData.data[fileData.position+(size*j)];
for(size_t i = 0; i < size; i++) {
outPtr[i] = inPtr[size-1 - i];
}
outPtr += size;
}
}
} // namespace ORCore
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r15
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_UC_ht+0xee20, %rsi
lea addresses_normal_ht+0x8760, %rdi
nop
nop
nop
sub %rbx, %rbx
mov $105, %rcx
rep movsb
nop
nop
nop
nop
nop
dec %r15
lea addresses_A_ht+0x92e6, %r11
nop
nop
cmp %r12, %r12
mov $0x6162636465666768, %rcx
movq %rcx, (%r11)
nop
nop
nop
nop
sub $28047, %r12
lea addresses_UC_ht+0xa020, %rdi
nop
nop
nop
nop
sub %r15, %r15
vmovups (%rdi), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %rbx
nop
nop
nop
inc %r11
lea addresses_A_ht+0xe20, %rsi
lea addresses_UC_ht+0xf654, %rdi
clflush (%rsi)
nop
nop
xor %rdx, %rdx
mov $2, %rcx
rep movsw
and %r12, %r12
lea addresses_A_ht+0x6220, %rsi
clflush (%rsi)
xor $52582, %r11
mov (%rsi), %bx
nop
nop
nop
cmp $28349, %rdi
lea addresses_WT_ht+0xa320, %rsi
clflush (%rsi)
nop
nop
nop
nop
sub $12789, %rcx
mov (%rsi), %r11d
nop
nop
nop
cmp $15768, %rsi
lea addresses_normal_ht+0xf820, %r12
nop
nop
nop
xor %rbx, %rbx
movw $0x6162, (%r12)
nop
nop
nop
and %rsi, %rsi
lea addresses_WC_ht+0x1301c, %rdi
nop
cmp %r11, %r11
vmovups (%rdi), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %rbx
nop
nop
nop
add $12607, %rbx
lea addresses_UC_ht+0xe86a, %rdx
clflush (%rdx)
nop
and %r15, %r15
mov $0x6162636465666768, %r11
movq %r11, %xmm1
movups %xmm1, (%rdx)
nop
nop
cmp %rdx, %rdx
lea addresses_UC_ht+0xce20, %r12
nop
sub %rdi, %rdi
vmovups (%r12), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $0, %xmm5, %rdx
xor $33792, %rsi
lea addresses_D_ht+0xe028, %rsi
nop
nop
nop
nop
and $41896, %rbx
movw $0x6162, (%rsi)
nop
nop
nop
nop
sub %r15, %r15
lea addresses_WC_ht+0xf0b8, %r15
nop
xor %rbx, %rbx
mov $0x6162636465666768, %r12
movq %r12, %xmm7
movups %xmm7, (%r15)
nop
nop
and %rbx, %rbx
lea addresses_normal_ht+0x13020, %rsi
lea addresses_UC_ht+0x13920, %rdi
add $13896, %rbx
mov $75, %rcx
rep movsl
nop
nop
add $31872, %rdi
lea addresses_A_ht+0x17f20, %r15
nop
nop
nop
nop
inc %rbx
mov (%r15), %esi
nop
cmp $22725, %r12
lea addresses_WT_ht+0x3e20, %rdx
sub %rsi, %rsi
movups (%rdx), %xmm5
vpextrq $1, %xmm5, %r12
nop
nop
nop
nop
nop
and $34904, %rsi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r15
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r14
push %r8
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
// Store
lea addresses_UC+0x9694, %r8
nop
sub $28361, %r14
movw $0x5152, (%r8)
inc %rdi
// Store
lea addresses_WC+0x1e1f0, %r8
and $18215, %rdi
mov $0x5152535455565758, %r14
movq %r14, %xmm6
movups %xmm6, (%r8)
nop
nop
sub %rbx, %rbx
// Store
lea addresses_PSE+0x4a60, %r11
sub $10899, %r8
mov $0x5152535455565758, %r14
movq %r14, (%r11)
nop
nop
nop
nop
nop
cmp %r14, %r14
// Store
lea addresses_WT+0x1fe58, %r10
add $32877, %rax
mov $0x5152535455565758, %r14
movq %r14, (%r10)
nop
nop
nop
cmp %r10, %r10
// Load
lea addresses_A+0xf80, %rbx
nop
nop
cmp %r11, %r11
mov (%rbx), %r14
nop
nop
nop
nop
nop
cmp %r11, %r11
// REPMOV
lea addresses_RW+0x1f8c0, %rsi
lea addresses_WT+0x1c448, %rdi
nop
nop
cmp %rax, %rax
mov $97, %rcx
rep movsw
nop
nop
nop
xor $16676, %r10
// Store
lea addresses_WT+0x7fa0, %rbx
clflush (%rbx)
nop
nop
nop
nop
nop
and %rsi, %rsi
mov $0x5152535455565758, %r10
movq %r10, %xmm3
movups %xmm3, (%rbx)
nop
nop
nop
sub $41441, %r14
// Store
lea addresses_UC+0x1b3e0, %r8
clflush (%r8)
nop
nop
nop
inc %r11
movb $0x51, (%r8)
nop
add $28706, %rbx
// Store
lea addresses_PSE+0xde20, %rcx
nop
nop
nop
nop
nop
sub $60259, %r8
movl $0x51525354, (%rcx)
nop
nop
nop
add $28333, %r11
// Store
lea addresses_RW+0xe560, %rax
nop
nop
nop
inc %rcx
movw $0x5152, (%rax)
nop
nop
xor %rsi, %rsi
// Store
mov $0xee0, %r14
clflush (%r14)
nop
nop
nop
and %rax, %rax
movl $0x51525354, (%r14)
nop
nop
nop
nop
nop
sub $20337, %r14
// Faulty Load
lea addresses_PSE+0xde20, %r10
clflush (%r10)
nop
dec %r8
vmovups (%r10), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $0, %xmm5, %rax
lea oracles, %rcx
and $0xff, %rax
shlq $12, %rax
mov (%rcx,%rax,1), %rax
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r8
pop %r14
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_PSE', 'same': True, 'size': 2, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_UC', 'same': False, 'size': 2, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WC', 'same': False, 'size': 16, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_PSE', 'same': False, 'size': 8, 'congruent': 6, 'NT': True, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WT', 'same': False, 'size': 8, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_A', 'same': False, 'size': 8, 'congruent': 5, 'NT': True, 'AVXalign': True}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_RW', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WT', 'congruent': 0, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_WT', 'same': False, 'size': 16, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_UC', 'same': False, 'size': 1, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_PSE', 'same': True, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_RW', 'same': False, 'size': 2, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_P', 'same': False, 'size': 4, 'congruent': 4, 'NT': True, 'AVXalign': True}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_PSE', 'same': True, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_UC_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 6, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 8, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 32, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 0, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_A_ht', 'same': False, 'size': 2, 'congruent': 8, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'same': False, 'size': 4, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 2, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 16, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 32, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 2, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WC_ht', 'same': False, 'size': 16, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_A_ht', 'same': False, 'size': 4, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'same': False, 'size': 16, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'33': 44}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2017 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <txdb.h>
#include <chainparams.h>
#include <hash.h>
#include <random.h>
#include <pow.h>
#include <uint256.h>
#include <util.h>
#include <ui_interface.h>
#include <init.h>
#include <stdint.h>
#include <boost/thread.hpp>
static const char DB_COIN = 'C';
static const char DB_COINS = 'c';
static const char DB_BLOCK_FILES = 'f';
static const char DB_TXINDEX = 't';
static const char DB_BLOCK_INDEX = 'b';
static const char DB_BEST_BLOCK = 'B';
static const char DB_HEAD_BLOCKS = 'H';
static const char DB_FLAG = 'F';
static const char DB_REINDEX_FLAG = 'R';
static const char DB_LAST_BLOCK = 'l';
namespace {
struct CoinEntry {
COutPoint* outpoint;
char key;
explicit CoinEntry(const COutPoint* ptr) : outpoint(const_cast<COutPoint*>(ptr)), key(DB_COIN) {}
template<typename Stream>
void Serialize(Stream &s) const {
s << key;
s << outpoint->hash;
s << VARINT(outpoint->n);
}
template<typename Stream>
void Unserialize(Stream& s) {
s >> key;
s >> outpoint->hash;
s >> VARINT(outpoint->n);
}
};
}
CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe, true)
{
}
bool CCoinsViewDB::GetCoin(const COutPoint &outpoint, Coin &coin) const {
return db.Read(CoinEntry(&outpoint), coin);
}
bool CCoinsViewDB::HaveCoin(const COutPoint &outpoint) const {
return db.Exists(CoinEntry(&outpoint));
}
uint256 CCoinsViewDB::GetBestBlock() const {
uint256 hashBestChain;
if (!db.Read(DB_BEST_BLOCK, hashBestChain))
return uint256();
return hashBestChain;
}
std::vector<uint256> CCoinsViewDB::GetHeadBlocks() const {
std::vector<uint256> vhashHeadBlocks;
if (!db.Read(DB_HEAD_BLOCKS, vhashHeadBlocks)) {
return std::vector<uint256>();
}
return vhashHeadBlocks;
}
bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
CDBBatch batch(db);
size_t count = 0;
size_t changed = 0;
size_t batch_size = (size_t)gArgs.GetArg("-dbbatchsize", nDefaultDbBatchSize);
int crash_simulate = gArgs.GetArg("-dbcrashratio", 0);
assert(!hashBlock.IsNull());
uint256 old_tip = GetBestBlock();
if (old_tip.IsNull()) {
// We may be in the middle of replaying.
std::vector<uint256> old_heads = GetHeadBlocks();
if (old_heads.size() == 2) {
assert(old_heads[0] == hashBlock);
old_tip = old_heads[1];
}
}
// In the first batch, mark the database as being in the middle of a
// transition from old_tip to hashBlock.
// A vector is used for future extensibility, as we may want to support
// interrupting after partial writes from multiple independent reorgs.
batch.Erase(DB_BEST_BLOCK);
batch.Write(DB_HEAD_BLOCKS, std::vector<uint256>{hashBlock, old_tip});
for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
if (it->second.flags & CCoinsCacheEntry::DIRTY) {
CoinEntry entry(&it->first);
if (it->second.coin.IsSpent())
batch.Erase(entry);
else
batch.Write(entry, it->second.coin);
changed++;
}
count++;
CCoinsMap::iterator itOld = it++;
mapCoins.erase(itOld);
if (batch.SizeEstimate() > batch_size) {
LogPrint(BCLog::COINDB, "Writing partial batch of %.2f MiB\n", batch.SizeEstimate() * (1.0 / 1048576.0));
db.WriteBatch(batch);
batch.Clear();
if (crash_simulate) {
static FastRandomContext rng;
if (rng.randrange(crash_simulate) == 0) {
LogPrintf("Simulating a crash. Goodbye.\n");
_Exit(0);
}
}
}
}
// In the last batch, mark the database as consistent with hashBlock again.
batch.Erase(DB_HEAD_BLOCKS);
batch.Write(DB_BEST_BLOCK, hashBlock);
LogPrint(BCLog::COINDB, "Writing final batch of %.2f MiB\n", batch.SizeEstimate() * (1.0 / 1048576.0));
bool ret = db.WriteBatch(batch);
LogPrint(BCLog::COINDB, "Committed %u changed transaction outputs (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count);
return ret;
}
size_t CCoinsViewDB::EstimateSize() const
{
return db.EstimateSize(DB_COIN, (char)(DB_COIN+1));
}
CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
}
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
}
bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
if (fReindexing)
return Write(DB_REINDEX_FLAG, '1');
else
return Erase(DB_REINDEX_FLAG);
}
bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
fReindexing = Exists(DB_REINDEX_FLAG);
return true;
}
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
return Read(DB_LAST_BLOCK, nFile);
}
CCoinsViewCursor *CCoinsViewDB::Cursor() const
{
CCoinsViewDBCursor *i = new CCoinsViewDBCursor(const_cast<CDBWrapper&>(db).NewIterator(), GetBestBlock());
/* It seems that there are no "const iterators" for LevelDB. Since we
only need read operations on it, use a const-cast to get around
that restriction. */
i->pcursor->Seek(DB_COIN);
// Cache key of first record
if (i->pcursor->Valid()) {
CoinEntry entry(&i->keyTmp.second);
i->pcursor->GetKey(entry);
i->keyTmp.first = entry.key;
} else {
i->keyTmp.first = 0; // Make sure Valid() and GetKey() return false
}
return i;
}
bool CCoinsViewDBCursor::GetKey(COutPoint &key) const
{
// Return cached key
if (keyTmp.first == DB_COIN) {
key = keyTmp.second;
return true;
}
return false;
}
bool CCoinsViewDBCursor::GetValue(Coin &coin) const
{
return pcursor->GetValue(coin);
}
unsigned int CCoinsViewDBCursor::GetValueSize() const
{
return pcursor->GetValueSize();
}
bool CCoinsViewDBCursor::Valid() const
{
return keyTmp.first == DB_COIN;
}
void CCoinsViewDBCursor::Next()
{
pcursor->Next();
CoinEntry entry(&keyTmp.second);
if (!pcursor->Valid() || !pcursor->GetKey(entry)) {
keyTmp.first = 0; // Invalidate cached key after last record so that Valid() and GetKey() return false
} else {
keyTmp.first = entry.key;
}
}
bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) {
CDBBatch batch(*this);
for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) {
batch.Write(std::make_pair(DB_BLOCK_FILES, it->first), *it->second);
}
batch.Write(DB_LAST_BLOCK, nLastFile);
for (std::vector<const CBlockIndex*>::const_iterator it=blockinfo.begin(); it != blockinfo.end(); it++) {
batch.Write(std::make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()), CDiskBlockIndex(*it));
}
return WriteBatch(batch, true);
}
bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
return Read(std::make_pair(DB_TXINDEX, txid), pos);
}
bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) {
CDBBatch batch(*this);
for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
batch.Write(std::make_pair(DB_TXINDEX, it->first), it->second);
return WriteBatch(batch);
}
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
}
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
char ch;
if (!Read(std::make_pair(DB_FLAG, name), ch))
return false;
fValue = ch == '1';
return true;
}
bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex)
{
std::unique_ptr<CDBIterator> pcursor(NewIterator());
pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
// Load mapBlockIndex
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
std::pair<char, uint256> key;
if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
CDiskBlockIndex diskindex;
if (pcursor->GetValue(diskindex)) {
// Construct block index object
CBlockIndex* pindexNew = insertBlockIndex(diskindex.GetBlockHash());
pindexNew->pprev = insertBlockIndex(diskindex.hashPrev);
pindexNew->nHeight = diskindex.nHeight;
pindexNew->nFile = diskindex.nFile;
pindexNew->nDataPos = diskindex.nDataPos;
pindexNew->nUndoPos = diskindex.nUndoPos;
pindexNew->nVersion = diskindex.nVersion;
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
pindexNew->nTime = diskindex.nTime;
pindexNew->nBits = diskindex.nBits;
pindexNew->nNonce = diskindex.nNonce;
pindexNew->nStatus = diskindex.nStatus;
pindexNew->nTx = diskindex.nTx;
// pos
pindexNew->nFlags = diskindex.nFlags;
pindexNew->nStakeModifier = diskindex.nStakeModifier;
pindexNew->hashProofOfStake = diskindex.hashProofOfStake;
pindexNew->nPowHeight = diskindex.nPowHeight;
pindexNew->outStakeReward = diskindex.outStakeReward;
if (pindexNew->IsProofOfWork() && !CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams))
return error("%s: CheckProofOfWork failed: %s", __func__, pindexNew->ToString());
pcursor->Next();
} else {
return error("%s: failed to read value", __func__);
}
} else {
break;
}
}
return true;
}
namespace {
//! Legacy class to deserialize pre-pertxout database entries without reindex.
class CCoins
{
public:
//! whether transaction is a coinbase
bool fCoinBase;
//! unspent transaction outputs; spent outputs are .IsNull(); spent outputs at the end of the array are dropped
std::vector<CTxOut> vout;
//! at which height this transaction was included in the active block chain
int nHeight;
//! empty constructor
CCoins() : fCoinBase(false), vout(0), nHeight(0) { }
template<typename Stream>
void Unserialize(Stream &s) {
unsigned int nCode = 0;
// version
int nVersionDummy;
::Unserialize(s, VARINT(nVersionDummy));
// header code
::Unserialize(s, VARINT(nCode));
fCoinBase = nCode & 1;
std::vector<bool> vAvail(2, false);
vAvail[0] = (nCode & 2) != 0;
vAvail[1] = (nCode & 4) != 0;
unsigned int nMaskCode = (nCode / 8) + ((nCode & 6) != 0 ? 0 : 1);
// spentness bitmask
while (nMaskCode > 0) {
unsigned char chAvail = 0;
::Unserialize(s, chAvail);
for (unsigned int p = 0; p < 8; p++) {
bool f = (chAvail & (1 << p)) != 0;
vAvail.push_back(f);
}
if (chAvail != 0)
nMaskCode--;
}
// txouts themself
vout.assign(vAvail.size(), CTxOut());
for (unsigned int i = 0; i < vAvail.size(); i++) {
if (vAvail[i])
::Unserialize(s, REF(CTxOutCompressor(vout[i])));
}
// coinbase height
::Unserialize(s, VARINT(nHeight));
}
};
}
/** Upgrade the database from older formats.
*
* Currently implemented: from the per-tx utxo model (0.8..0.14.x) to per-txout.
*/
bool CCoinsViewDB::Upgrade() {
std::unique_ptr<CDBIterator> pcursor(db.NewIterator());
pcursor->Seek(std::make_pair(DB_COINS, uint256()));
if (!pcursor->Valid()) {
return true;
}
int64_t count = 0;
LogPrintf("Upgrading utxo-set database...\n");
LogPrintf("[0%%]...");
uiInterface.ShowProgress(_("Upgrading UTXO database"), 0, true);
size_t batch_size = 1 << 24;
CDBBatch batch(db);
int reportDone = 0;
std::pair<unsigned char, uint256> key;
std::pair<unsigned char, uint256> prev_key = {DB_COINS, uint256()};
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
if (ShutdownRequested()) {
break;
}
if (pcursor->GetKey(key) && key.first == DB_COINS) {
if (count++ % 256 == 0) {
uint32_t high = 0x100 * *key.second.begin() + *(key.second.begin() + 1);
int percentageDone = (int)(high * 100.0 / 65536.0 + 0.5);
uiInterface.ShowProgress(_("Upgrading UTXO database"), percentageDone, true);
if (reportDone < percentageDone/10) {
// report max. every 10% step
LogPrintf("[%d%%]...", percentageDone);
reportDone = percentageDone/10;
}
}
CCoins old_coins;
if (!pcursor->GetValue(old_coins)) {
return error("%s: cannot parse CCoins record", __func__);
}
COutPoint outpoint(key.second, 0);
for (size_t i = 0; i < old_coins.vout.size(); ++i) {
if (!old_coins.vout[i].IsNull() && !old_coins.vout[i].scriptPubKey.IsUnspendable()) {
Coin newcoin(std::move(old_coins.vout[i]), old_coins.nHeight, 0, old_coins.fCoinBase);
outpoint.n = i;
CoinEntry entry(&outpoint);
batch.Write(entry, newcoin);
}
}
batch.Erase(key);
if (batch.SizeEstimate() > batch_size) {
db.WriteBatch(batch);
batch.Clear();
db.CompactRange(prev_key, key);
prev_key = key;
}
pcursor->Next();
} else {
break;
}
}
db.WriteBatch(batch);
db.CompactRange({DB_COINS, uint256()}, key);
uiInterface.ShowProgress("", 100, false);
LogPrintf("[%s].\n", ShutdownRequested() ? "CANCELLED" : "DONE");
return !ShutdownRequested();
}
|
; void __CALLEE__ *im2_InstallISR_callee(uchar vector, void *isr)
; 04.2004 aralbrec
XLIB im2_InstallISR_callee
XDEF ASMDISP_IM2_INSTALLISR_CALLEE
.im2_InstallISR_callee
pop hl
pop de
ex (sp),hl
.asmentry
; enter: l = vector to install on (even by convention)
; de = new ISR address
; exit : hl = old ISR address
; uses : af, de, hl
.IM2InstallISR
ld a,i
ld h,a
ld a,(hl)
ld (hl),e
ld e,a
inc hl
ld a,(hl)
ld (hl),d
ld d,a
ex de,hl
ret
DEFC ASMDISP_IM2_INSTALLISR_CALLEE = asmentry - im2_InstallISR_callee
|
//////////////////////////////////////////////////////////////////////////
// monster_community.cpp: структура представления группировки для монстров
//
//////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "monster_community.h"
#define MONSTER_RELATIONS_SECT "monster_communities"
#define MONSTER_COMMUNITIES "communities"
#define MONSTER_RELATIONS_TABLE "monster_relations"
//////////////////////////////////////////////////////////////////////////
MONSTER_COMMUNITY_DATA::MONSTER_COMMUNITY_DATA (MONSTER_COMMUNITY_INDEX idx, MONSTER_COMMUNITY_ID idn, LPCSTR team_str)
{
index = idx;
id = idn;
team = (u8)atoi(team_str);
}
//////////////////////////////////////////////////////////////////////////
MONSTER_COMMUNITY::MONSTER_RELATION_TABLE MONSTER_COMMUNITY::m_relation_table;
//////////////////////////////////////////////////////////////////////////
MONSTER_COMMUNITY::MONSTER_COMMUNITY ()
{
m_current_index = NO_MONSTER_COMMUNITY_INDEX;
}
MONSTER_COMMUNITY::~MONSTER_COMMUNITY ()
{
}
void MONSTER_COMMUNITY::set (MONSTER_COMMUNITY_ID id)
{
m_current_index = IdToIndex(id);
}
void MONSTER_COMMUNITY::set (MONSTER_COMMUNITY_INDEX index)
{
m_current_index = index;
}
MONSTER_COMMUNITY_ID MONSTER_COMMUNITY::id () const
{
return IndexToId(m_current_index);
}
MONSTER_COMMUNITY_INDEX MONSTER_COMMUNITY::index () const
{
return m_current_index;
}
u8 MONSTER_COMMUNITY::team () const
{
return (*m_pItemDataVector)[m_current_index].team;
}
void MONSTER_COMMUNITY::InitIdToIndex ()
{
section_name = MONSTER_RELATIONS_SECT;
line_name = MONSTER_COMMUNITIES;
m_relation_table.set_table_params(MONSTER_RELATIONS_TABLE);
}
int MONSTER_COMMUNITY::relation (MONSTER_COMMUNITY_INDEX to)
{
return relation(m_current_index, to);
}
int MONSTER_COMMUNITY::relation (MONSTER_COMMUNITY_INDEX from, MONSTER_COMMUNITY_INDEX to)
{
VERIFY(from >= 0 && from <(int)m_relation_table.table().size());
VERIFY(to >= 0 && to <(int)m_relation_table.table().size());
return m_relation_table.table()[from][to];
}
void MONSTER_COMMUNITY::DeleteIdToIndexData ()
{
m_relation_table.clear();
inherited::DeleteIdToIndexData();
}
void MONSTER_COMMUNITY::set_relation ( MONSTER_COMMUNITY_ID from, MONSTER_COMMUNITY_ID to, int rel ) {
MONSTER_COMMUNITY_INDEX idx_from = IdToIndex( from );
MONSTER_COMMUNITY_INDEX idx_to = IdToIndex( to );
m_relation_table.table()[ idx_from ][ idx_to ] = rel;
}
|
; A021282: Decimal expansion of 1/278.
; Submitted by Jon Maiga
; 0,0,3,5,9,7,1,2,2,3,0,2,1,5,8,2,7,3,3,8,1,2,9,4,9,6,4,0,2,8,7,7,6,9,7,8,4,1,7,2,6,6,1,8,7,0,5,0,3,5,9,7,1,2,2,3,0,2,1,5,8,2,7,3,3,8,1,2,9,4,9,6,4,0,2,8,7,7,6,9,7,8,4,1,7,2,6,6,1,8,7,0,5,0,3,5,9,7,1
seq $0,173833 ; 10^n - 3.
div $0,278
mod $0,10
|
NOP
; write to memory-mapped video
LDA #%i1i1i
.equ $wdddd video_start
.equ $ddddd video_end
STA video_start
STA $wdddd
STA $0zzzz
STA $0zzzy
STA $0zzzx
STA $0zzzw
STA $0zzz0
STA $0zzza
.equ -3282 chargen
.equ -3283 row
.equ -3284 col
.equ -3286 beep
; write to text character generator
LDA #'X
LDX #0
STX row
LDY #4
STY col
LDX #1
STA chargen
ADC #2
STI A ; simple ternary inverter
STA chargen ; trit-text red 'Z'
LDX #4
INX
STX col
DEC chargen ; trit-text 'Y'
TXA ; X->A, 5
; setup stack, since default 0 overlaps with memory-mapped screen output
.equ -10000 stack
LDY #>stack
LDX #<stack
TXYS
; loop 6..19
loop:
INC A
STA col
STA chargen
CMP #20
;BNE #-11
BNE loop
LDA #1
STA row
STZ col
; print greeting
LDA #<greeting
LDX #>greeting
JSR print_string
INC row
STZ col
LDA #<prompt_string
LDX #>prompt_string
JSR print_string
;STZ beep
; set input interrupt handler
.equ -29524 int_inputL
.equ -29523 int_inputH
LDA #<handle_input
STA int_inputL
LDA #>handle_input
STA int_inputH
SEIP ; enable interrupt -1 (keyboard input) TODO: also handle int 1, then can unmask all with CLI
; set pulse interrupt handler
.equ -29520 int_pulseL
.equ -29519 int_pulseH
LDA #<handle_pulse
STA int_pulseL
LDA #>handle_pulse
STA int_pulseH
CLI ; enable all interrupts
LDA #'_ ; a suitable cursor character
;LDA #'▒ ; alternative block cursor TODO: use in 'insert' mode?
STA cursor_char
.equ -3285 timer_freq
LDA #1 ; 100 ms
; cursor blink - disable when want quiescence (noisy)
STA timer_freq ; triggers interrupt immediately.. TODO: probably should delay! or never returns?
;
HALTZ
cursor_char:
.tryte 0
greeting:
.data "Hello, world! ☺ 3502 CPU online: system ready---------------------------------------------"
.tryte 0
prompt_string:
;TODO: support newlines in print_string '.tryte 12', // trit-text newline TODO: support embedding in .data
.data "$ "
.tryte 0
bad_command_string:
.data "Bad command or file name: "
.tryte 0
help_command_string:
.data "Available commands: "
.data "Help: "
.data "beep - sound a beep through the speaker "
.data "clear - clear terminal screen display "
.data "help - show help on supported commands "
.data "read - read data from floppy disk "
.data "write - write data to floppy disk "
.data "echo - echo input to terminal "
.tryte 0
handle_pulse:
; blinking cursor
LDA cursor_char
STA chargen
STI cursor_char ; simple ternary inverter, toggle red/green '_'
RTI ; return from interrupt
; subroutine to advance terminal to next line
next_line:
INC row
STZ col
RTS
handle_prev_line:
DEC row
LDA #44 ; TODO: .equ
STA col
JMP handled_input
handle_backspace:
JSR truncate_line_buffer
BCS handle_backspace_denied ; if couldn't delete
STZ chargen ; clear cursor
DEC col
LDA col
CMP #-1
BEQ handle_prev_line
STZ chargen
JMP handled_input
handle_backspace_denied:
STZ beep ; user feedback that their backspacing was denied
JMP handled_input
handle_enter:
STZ chargen ; clear cursor
JSR next_line
; check commands TODO: strcmp, check full string instead of only first character
LDY #0
LDA #'\0
CMP line_buffer,Y
BEQ command_null
LDA #'b
CMP line_buffer,Y
BEQ command_beep
LDA #'c
CMP line_buffer,Y
BEQ command_clear
LDA #'h
CMP line_buffer,Y
BEQ command_help
LDA #'r
CMP line_buffer,Y
BEQ command_read
LDA #'w
CMP line_buffer,Y
BEQ command_write
LDA #'e
CMP line_buffer,Y
BEQ command_echo
JMP command_bad
handle_enter_done:
JSR reset_line_buffer
STZ col
LDA #<prompt_string
LDX #>prompt_string
JSR print_string
JMP handled_input
; interrupt handler:
handle_input:
CMP #'\n
BEQ handle_enter
CMP #0
BEQ handle_backspace
JSR save_line_buffer_char
JSR print_char
handled_input:
RTI
command_bad:
LDA #<bad_command_string
LDX #>bad_command_string
JSR print_string
LDA #<line_buffer
LDX #>line_buffer
JSR print_string
INC row
JMP handle_enter_done
command_help:
LDA #<help_command_string
LDX #>help_command_string
JSR print_string
JMP handle_enter_done
command_beep:
STA beep
JMP handle_enter_done
command_null:
JMP handle_enter_done
command_read:
JMP command_read2 ; too far
command_write:
JMP command_write2
command_echo:
LDA #<line_buffer
LDX #>line_buffer
JSR print_string
INC row
JMP handle_enter_done
.equ 45 col_count
.equ 28 row_count
command_clear:
STZ col
STZ row
_command_clear_next_row:
_command_clear_next_col:
STZ chargen ; write empty character at each cursor position to clear terminal TODO: instead write to tritmapped memory?
INC col
LDA col
CMP #col_count
BNE _command_clear_next_col
INC row
LDA row
CMP #row_count
BNE _command_clear_next_row
STZ beep ; beep when done
STZ col ; reset cursor to beginning
STZ row
JMP handle_enter_done
; append character in A to line_buffer
save_line_buffer_char:
LDY line_buffer_offset
STA line_buffer,Y
INC line_buffer_offset
INY
LDX #0
STX line_buffer,Y ; null terminate
RTS
line_buffer_offset:
.tryte 0
; reset line buffer to empty string
reset_line_buffer:
STZ line_buffer_offset
STZ line_buffer
RTS
; delete last character of line buffer, sets carry flag if cannot be deleted
truncate_line_buffer:
LDY line_buffer_offset
DEY
CPY #0
BMI _truncate_line_buffer_skip ; empty buffer, cannot truncate further
STZ line_buffer,Y
STY line_buffer_offset
CLC
RTS
_truncate_line_buffer_skip:
SECN
RTS
; print character in A to screen and advance cursor
print_char:
STA chargen
INC col
LDX col
CPX #col_count
BNE print_char_done
JSR next_line ; at last column, wrap cursor to next line
print_char_done:
RTS
; print a null-terminated string pointed to by A,X
print_string:
STA _print_string_param
STX _print_string_param+1
LDY #0
_print_string_loop:
LDA (_print_string_param),Y
CMP #0
BEQ _print_string_done
JSR print_char
LDA #1
ADC _print_string_param
STA _print_string_param
LDA #0
ADC _print_string_param+1
STA _print_string_param+1
BRA _print_string_loop
_print_string_done:
RTS
_print_string_param:
.word 0
.equ -3290 floppy_data_ptr
.equ -3292 floppy_name_ptr
.equ -3294 floppy_length_ptr
.equ -3296 floppy_command_execute
.equ -1 floppy_command_read
.equ 0 floppy_command_write
; write data to floppy (similar to echo text > filename TODO)
command_write2:
LDA #<line_buffer
LDX #>line_buffer
STA floppy_data_ptr ; TODO: increment pointer to remove command prefix
STX floppy_data_ptr+1
LDA #<filename
LDX #>filename
STA floppy_name_ptr
STX floppy_name_ptr+1
LDA #floppy_command_write
STA floppy_command_execute ; TODO: print out number of trytes written? to filename?
JMP handle_enter_done
; read data from floppy TODO: rename 'cat'...? Unix
command_read2:
LDA #<line_buffer
LDX #>line_buffer
STA floppy_data_ptr
STX floppy_data_ptr+1
LDA #<filename
LDX #>filename
STA floppy_name_ptr
STX floppy_name_ptr+1
LDA #floppy_command_read
STA floppy_command_execute
LDA #<line_buffer
LDX #>line_buffer
JSR print_string
INC row
STZ col
JMP handle_enter_done
; floppy filename TODO: read from argument
filename:
.data "hi"
.tryte 0
line_buffer:
.tryte 0 ; may extend further
|
lda {m2}
sec
sbc {m3}+2
sta {m1}
lda {m2}+1
sbc {m3}+3
sta {m1}+1
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r8
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x135af, %r11
clflush (%r11)
nop
nop
nop
cmp %rbx, %rbx
mov (%r11), %r8d
nop
nop
sub $7919, %rbp
lea addresses_WC_ht+0x180ef, %rsi
lea addresses_D_ht+0x15a87, %rdi
nop
nop
dec %rax
mov $10, %rcx
rep movsb
nop
nop
nop
nop
add %rbp, %rbp
lea addresses_WT_ht+0x941, %r11
nop
xor $4771, %rcx
mov (%r11), %r8
nop
nop
nop
nop
cmp %r11, %r11
lea addresses_WT_ht+0x8fef, %rsi
nop
nop
cmp %rdi, %rdi
vmovups (%rsi), %ymm7
vextracti128 $0, %ymm7, %xmm7
vpextrq $0, %xmm7, %r11
nop
nop
nop
nop
nop
and %rbp, %rbp
lea addresses_D_ht+0x5d57, %rax
nop
nop
and $57284, %rbx
and $0xffffffffffffffc0, %rax
movntdqa (%rax), %xmm7
vpextrq $1, %xmm7, %rcx
nop
nop
nop
nop
nop
cmp $15381, %rsi
lea addresses_UC_ht+0x26f7, %r11
nop
nop
nop
nop
xor %rcx, %rcx
mov (%r11), %edi
xor %r8, %r8
lea addresses_WC_ht+0x12ef, %rbx
nop
nop
nop
nop
nop
and $3049, %rcx
movw $0x6162, (%rbx)
nop
nop
nop
nop
inc %rbp
lea addresses_WT_ht+0xaa3f, %rsi
nop
nop
nop
nop
nop
sub $44346, %r8
mov $0x6162636465666768, %r11
movq %r11, %xmm4
vmovups %ymm4, (%rsi)
nop
nop
nop
nop
nop
sub $35650, %r11
lea addresses_normal_ht+0x16f6f, %rdi
cmp %rcx, %rcx
movb $0x61, (%rdi)
nop
nop
nop
nop
nop
sub $46563, %rax
lea addresses_D_ht+0x996f, %rsi
lea addresses_WC_ht+0xd3ef, %rdi
and %rax, %rax
mov $51, %rcx
rep movsb
nop
nop
nop
nop
nop
and $36829, %rcx
lea addresses_WT_ht+0x17513, %rbx
nop
nop
sub %rax, %rax
mov $0x6162636465666768, %r11
movq %r11, (%rbx)
nop
nop
nop
nop
nop
cmp $44709, %rax
lea addresses_WT_ht+0x85ef, %rcx
nop
nop
nop
xor $23850, %rsi
movl $0x61626364, (%rcx)
nop
nop
nop
and $704, %r11
lea addresses_normal_ht+0x1499f, %rsi
lea addresses_WC_ht+0xb32f, %rdi
nop
nop
xor %r11, %r11
mov $49, %rcx
rep movsb
nop
nop
nop
sub $14698, %rdi
lea addresses_WT_ht+0x1d7f3, %rsi
clflush (%rsi)
nop
nop
nop
nop
xor $56875, %rdi
mov $0x6162636465666768, %r8
movq %r8, %xmm4
and $0xffffffffffffffc0, %rsi
movaps %xmm4, (%rsi)
nop
nop
and $20116, %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r8
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %rbp
push %rcx
push %rdi
push %rsi
// Faulty Load
lea addresses_normal+0x1efef, %rcx
nop
nop
nop
nop
xor $45774, %r13
movb (%rcx), %r11b
lea oracles, %r13
and $0xff, %r11
shlq $12, %r11
mov (%r13,%r11,1), %r11
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 1, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 6}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D_ht', 'congruent': 3, 'same': True}}
{'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 1}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 10}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 16, 'NT': True, 'same': False, 'congruent': 3}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 4, 'NT': True, 'same': False, 'congruent': 3}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 4}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 5}}
{'src': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 2}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 7}}
{'src': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 4, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': True, 'size': 16, 'NT': False, 'same': False, 'congruent': 2}}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r13
push %r14
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x13cec, %r13
nop
nop
nop
nop
cmp %rax, %rax
movups (%r13), %xmm4
vpextrq $1, %xmm4, %rsi
add $52156, %r14
lea addresses_WC_ht+0xc9ec, %rsi
lea addresses_normal_ht+0x1514c, %rdi
nop
xor %r10, %r10
mov $125, %rcx
rep movsq
nop
nop
nop
nop
nop
add %r13, %r13
lea addresses_D_ht+0x70fc, %r10
nop
nop
nop
nop
nop
sub %r14, %r14
mov $0x6162636465666768, %rdi
movq %rdi, %xmm0
vmovups %ymm0, (%r10)
cmp $24647, %r13
lea addresses_A_ht+0x1a666, %rsi
lea addresses_WC_ht+0x1336c, %rdi
nop
nop
nop
nop
nop
add %rbx, %rbx
mov $94, %rcx
rep movsl
nop
nop
nop
cmp %r13, %r13
lea addresses_WC_ht+0x8eec, %rbx
nop
and %rsi, %rsi
mov $0x6162636465666768, %r10
movq %r10, %xmm1
vmovups %ymm1, (%rbx)
nop
nop
nop
nop
nop
inc %rbx
lea addresses_WC_ht+0xe2ec, %r10
nop
dec %r14
mov (%r10), %esi
nop
nop
nop
nop
add %r14, %r14
lea addresses_UC_ht+0x1e97c, %rsi
lea addresses_A_ht+0x78ec, %rdi
nop
nop
nop
nop
and %rax, %rax
mov $59, %rcx
rep movsq
nop
nop
nop
inc %r10
lea addresses_WT_ht+0x15dec, %r14
nop
cmp $11080, %r10
mov $0x6162636465666768, %rdi
movq %rdi, %xmm1
vmovups %ymm1, (%r14)
nop
nop
nop
add %r14, %r14
lea addresses_UC_ht+0x90c4, %rsi
lea addresses_A_ht+0x1b76c, %rdi
nop
nop
and $44559, %r10
mov $18, %rcx
rep movsw
nop
nop
nop
cmp $33344, %rsi
lea addresses_WT_ht+0x1e7ec, %rsi
lea addresses_normal_ht+0xa72c, %rdi
nop
nop
nop
nop
nop
sub %rbx, %rbx
mov $120, %rcx
rep movsq
nop
nop
nop
nop
nop
xor $39937, %rdi
lea addresses_D_ht+0x1b329, %r13
nop
dec %rax
mov $0x6162636465666768, %rsi
movq %rsi, %xmm0
vmovups %ymm0, (%r13)
nop
nop
nop
nop
cmp %r14, %r14
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r14
pop %r13
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r13
push %r9
push %rax
push %rcx
push %rsi
// Load
lea addresses_US+0x7683, %rax
nop
inc %rsi
movups (%rax), %xmm0
vpextrq $1, %xmm0, %r13
nop
xor %r12, %r12
// Load
lea addresses_UC+0x1a30c, %r10
nop
nop
and %r13, %r13
movups (%r10), %xmm5
vpextrq $0, %xmm5, %rsi
nop
nop
nop
nop
xor %r10, %r10
// Load
mov $0x6b0f4400000006ec, %rsi
and %rcx, %rcx
mov (%rsi), %eax
nop
sub $38215, %r9
// Store
lea addresses_US+0x18d7c, %r12
clflush (%r12)
nop
nop
nop
nop
xor $50531, %r10
movw $0x5152, (%r12)
xor %rcx, %rcx
// Store
lea addresses_WT+0x156ec, %r12
nop
nop
nop
nop
dec %r10
mov $0x5152535455565758, %r13
movq %r13, %xmm2
movups %xmm2, (%r12)
nop
nop
cmp %r10, %r10
// Load
lea addresses_PSE+0x142ec, %rcx
nop
nop
nop
cmp %r13, %r13
movb (%rcx), %al
nop
nop
nop
nop
sub %rax, %rax
// Store
mov $0x51888d0000000d6c, %r13
nop
xor $53037, %r10
movb $0x51, (%r13)
nop
inc %rcx
// Faulty Load
lea addresses_D+0xdeec, %r12
clflush (%r12)
nop
nop
dec %rcx
mov (%r12), %r10
lea oracles, %rax
and $0xff, %r10
shlq $12, %r10
mov (%rax,%r10,1), %r10
pop %rsi
pop %rcx
pop %rax
pop %r9
pop %r13
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_D', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_US', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 10, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 10, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_NC', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_D', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 6, 'same': True}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 5, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 4, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 6, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'36': 236}
36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36
*/
|
; A288834: a(n) = (n+1) * 3^(n-1).
; 2,9,36,135,486,1701,5832,19683,65610,216513,708588,2302911,7440174,23914845,76527504,243931419,774840978,2453663097,7748409780,24407490807,76709256822,240588123669,753145430616,2353579470675,7343167948506,22876792454961
mov $1,$0
add $1,2
mov $2,3
pow $2,$0
mul $1,$2
|
.include "m16def.inc"
.DEF A = r16 ;input A - PORTA LSB(0)
.DEF B = r17 ;input B - PORTA LSB(1)
.DEF C = r18 ;input C - PORTA LSB(2)
.DEF D = r19 ;input D - PORTA LSB(3)
.DEF I = r20 ;register to store input
.DEF E = r21 ;register for temporary calculations
.DEF F = r22 ;register for temporary calculations
;========== INITIALIZE STACK POINTER , I/O ==========
reset:
ldi r24 , low(RAMEND) ;initialize stack pointer (LOW)
out SPL , r24
ldi r24 , high(RAMEND) ;initialize stack pointer (HIGH)
out SPH , r24
ser r26
out DDRB, r26 ;initialize PORTB
clr r26
out DDRA, r26 ;initialize PORTA
;========== DATA INPUT ==========
main:
clr E ; CLEAR E
clr F ; CLEAR F
in I, PINA ; I <- INPUT
mov A, I ; LSB(0) = A
lsr I ; rotate right INPUT
mov B, I ; LSB(1) = B
lsr I ; rotate right INPUT
mov C, I ; LSB(2) = C
lsr I ; rotate right INPUT
mov D, I ; LSB(3) = D
;========== ROUTINE FOR F0 =============
mov F, C ; F = C
com F ; F = C'
and F, A ; F = AC'
and F, B ; F = ABC'
mov E, C ; E = C
and E, D ; E = CD
or F, E ; F = (ABC' + CD)
com F ; F = (ABC' + CD)' -> F0
;========== ROUTINE FOR F1 ==============
or A, B ; A = A + B
or C, D ; C = C + D
and A, C ; A = (A + B)(C + D) -> F1
lsl A ; rotate left A
andi F, 1 ; F = F0 (0000 0001 MASK)
andi A, 2 ; A = F1 (0000 0010 MASK)
or F, A ; COMBINE F0, F1
out PORTB, F ; OUTPUT F0-F1 IN PORTB
rjmp reset |
; Automatically generated by configure - do not modify!
%define ARCH_AARCH64 0
%define ARCH_ALPHA 0
%define ARCH_ARM 0
%define ARCH_AVR32 0
%define ARCH_AVR32_AP 0
%define ARCH_AVR32_UC 0
%define ARCH_BFIN 0
%define ARCH_IA64 0
%define ARCH_M68K 0
%define ARCH_MIPS 0
%define ARCH_MIPS64 0
%define ARCH_PARISC 0
%define ARCH_PPC 0
%define ARCH_PPC64 0
%define ARCH_S390 0
%define ARCH_SH4 0
%define ARCH_SPARC 0
%define ARCH_SPARC64 0
%define ARCH_TILEGX 0
%define ARCH_TILEPRO 0
%define ARCH_TOMI 0
%define ARCH_X86 1
%define ARCH_X86_32 0
%define ARCH_X86_64 1
%define HAVE_ARMV5TE 0
%define HAVE_ARMV6 0
%define HAVE_ARMV6T2 0
%define HAVE_ARMV8 0
%define HAVE_NEON 0
%define HAVE_VFP 0
%define HAVE_VFPV3 0
%define HAVE_SETEND 0
%define HAVE_ALTIVEC 0
%define HAVE_DCBZL 0
%define HAVE_LDBRX 0
%define HAVE_POWER8 0
%define HAVE_PPC4XX 0
%define HAVE_VSX 0
%define HAVE_AESNI 1
%define HAVE_AMD3DNOW 1
%define HAVE_AMD3DNOWEXT 1
%define HAVE_AVX 1
%define HAVE_AVX2 1
%define HAVE_AVX512 1
%define HAVE_FMA3 1
%define HAVE_FMA4 1
%define HAVE_MMX 1
%define HAVE_MMXEXT 1
%define HAVE_SSE 1
%define HAVE_SSE2 1
%define HAVE_SSE3 1
%define HAVE_SSE4 1
%define HAVE_SSE42 1
%define HAVE_SSSE3 1
%define HAVE_XOP 1
%define HAVE_CPUNOP 1
%define HAVE_I686 1
%define HAVE_MIPSFPU 0
%define HAVE_MIPS32R2 0
%define HAVE_MIPS32R5 0
%define HAVE_MIPS64R2 0
%define HAVE_MIPS32R6 0
%define HAVE_MIPS64R6 0
%define HAVE_MIPSDSP 0
%define HAVE_MIPSDSPR2 0
%define HAVE_MSA 0
%define HAVE_MSA2 0
%define HAVE_LOONGSON2 0
%define HAVE_LOONGSON3 0
%define HAVE_MMI 0
%define HAVE_ARMV5TE_EXTERNAL 0
%define HAVE_ARMV6_EXTERNAL 0
%define HAVE_ARMV6T2_EXTERNAL 0
%define HAVE_ARMV8_EXTERNAL 0
%define HAVE_NEON_EXTERNAL 0
%define HAVE_VFP_EXTERNAL 0
%define HAVE_VFPV3_EXTERNAL 0
%define HAVE_SETEND_EXTERNAL 0
%define HAVE_ALTIVEC_EXTERNAL 0
%define HAVE_DCBZL_EXTERNAL 0
%define HAVE_LDBRX_EXTERNAL 0
%define HAVE_POWER8_EXTERNAL 0
%define HAVE_PPC4XX_EXTERNAL 0
%define HAVE_VSX_EXTERNAL 0
%define HAVE_AESNI_EXTERNAL 1
%define HAVE_AMD3DNOW_EXTERNAL 1
%define HAVE_AMD3DNOWEXT_EXTERNAL 1
%define HAVE_AVX_EXTERNAL 1
%define HAVE_AVX2_EXTERNAL 1
%define HAVE_AVX512_EXTERNAL 0
%define HAVE_FMA3_EXTERNAL 1
%define HAVE_FMA4_EXTERNAL 1
%define HAVE_MMX_EXTERNAL 1
%define HAVE_MMXEXT_EXTERNAL 1
%define HAVE_SSE_EXTERNAL 1
%define HAVE_SSE2_EXTERNAL 1
%define HAVE_SSE3_EXTERNAL 1
%define HAVE_SSE4_EXTERNAL 1
%define HAVE_SSE42_EXTERNAL 1
%define HAVE_SSSE3_EXTERNAL 1
%define HAVE_XOP_EXTERNAL 1
%define HAVE_CPUNOP_EXTERNAL 0
%define HAVE_I686_EXTERNAL 0
%define HAVE_MIPSFPU_EXTERNAL 0
%define HAVE_MIPS32R2_EXTERNAL 0
%define HAVE_MIPS32R5_EXTERNAL 0
%define HAVE_MIPS64R2_EXTERNAL 0
%define HAVE_MIPS32R6_EXTERNAL 0
%define HAVE_MIPS64R6_EXTERNAL 0
%define HAVE_MIPSDSP_EXTERNAL 0
%define HAVE_MIPSDSPR2_EXTERNAL 0
%define HAVE_MSA_EXTERNAL 0
%define HAVE_MSA2_EXTERNAL 0
%define HAVE_LOONGSON2_EXTERNAL 0
%define HAVE_LOONGSON3_EXTERNAL 0
%define HAVE_MMI_EXTERNAL 0
%define HAVE_ARMV5TE_INLINE 0
%define HAVE_ARMV6_INLINE 0
%define HAVE_ARMV6T2_INLINE 0
%define HAVE_ARMV8_INLINE 0
%define HAVE_NEON_INLINE 0
%define HAVE_VFP_INLINE 0
%define HAVE_VFPV3_INLINE 0
%define HAVE_SETEND_INLINE 0
%define HAVE_ALTIVEC_INLINE 0
%define HAVE_DCBZL_INLINE 0
%define HAVE_LDBRX_INLINE 0
%define HAVE_POWER8_INLINE 0
%define HAVE_PPC4XX_INLINE 0
%define HAVE_VSX_INLINE 0
%define HAVE_AESNI_INLINE 1
%define HAVE_AMD3DNOW_INLINE 1
%define HAVE_AMD3DNOWEXT_INLINE 1
%define HAVE_AVX_INLINE 1
%define HAVE_AVX2_INLINE 1
%define HAVE_AVX512_INLINE 1
%define HAVE_FMA3_INLINE 1
%define HAVE_FMA4_INLINE 1
%define HAVE_MMX_INLINE 1
%define HAVE_MMXEXT_INLINE 1
%define HAVE_SSE_INLINE 1
%define HAVE_SSE2_INLINE 1
%define HAVE_SSE3_INLINE 1
%define HAVE_SSE4_INLINE 1
%define HAVE_SSE42_INLINE 1
%define HAVE_SSSE3_INLINE 1
%define HAVE_XOP_INLINE 1
%define HAVE_CPUNOP_INLINE 0
%define HAVE_I686_INLINE 0
%define HAVE_MIPSFPU_INLINE 0
%define HAVE_MIPS32R2_INLINE 0
%define HAVE_MIPS32R5_INLINE 0
%define HAVE_MIPS64R2_INLINE 0
%define HAVE_MIPS32R6_INLINE 0
%define HAVE_MIPS64R6_INLINE 0
%define HAVE_MIPSDSP_INLINE 0
%define HAVE_MIPSDSPR2_INLINE 0
%define HAVE_MSA_INLINE 0
%define HAVE_MSA2_INLINE 0
%define HAVE_LOONGSON2_INLINE 0
%define HAVE_LOONGSON3_INLINE 0
%define HAVE_MMI_INLINE 0
%define HAVE_ALIGNED_STACK 1
%define HAVE_FAST_64BIT 1
%define HAVE_FAST_CLZ 1
%define HAVE_FAST_CMOV 1
%define HAVE_LOCAL_ALIGNED 1
%define HAVE_SIMD_ALIGN_16 1
%define HAVE_SIMD_ALIGN_32 1
%define HAVE_SIMD_ALIGN_64 1
%define HAVE_ATOMIC_CAS_PTR 0
%define HAVE_MACHINE_RW_BARRIER 0
%define HAVE_MEMORYBARRIER 0
%define HAVE_MM_EMPTY 1
%define HAVE_RDTSC 0
%define HAVE_SEM_TIMEDWAIT 0
%define HAVE_SYNC_VAL_COMPARE_AND_SWAP 1
%define HAVE_CABS 1
%define HAVE_CEXP 1
%define HAVE_INLINE_ASM 1
%define HAVE_SYMVER 1
%define HAVE_X86ASM 1
%define HAVE_BIGENDIAN 0
%define HAVE_FAST_UNALIGNED 1
%define HAVE_ARPA_INET_H 1
%define HAVE_ASM_TYPES_H 0
%define HAVE_CDIO_PARANOIA_H 0
%define HAVE_CDIO_PARANOIA_PARANOIA_H 0
%define HAVE_CUDA_H 0
%define HAVE_DISPATCH_DISPATCH_H 1
%define HAVE_DEV_BKTR_IOCTL_BT848_H 0
%define HAVE_DEV_BKTR_IOCTL_METEOR_H 0
%define HAVE_DEV_IC_BT8XX_H 0
%define HAVE_DEV_VIDEO_BKTR_IOCTL_BT848_H 0
%define HAVE_DEV_VIDEO_METEOR_IOCTL_METEOR_H 0
%define HAVE_DIRECT_H 0
%define HAVE_DIRENT_H 1
%define HAVE_DXGIDEBUG_H 0
%define HAVE_DXVA_H 0
%define HAVE_ES2_GL_H 0
%define HAVE_GSM_H 0
%define HAVE_IO_H 0
%define HAVE_LINUX_PERF_EVENT_H 0
%define HAVE_MACHINE_IOCTL_BT848_H 0
%define HAVE_MACHINE_IOCTL_METEOR_H 0
%define HAVE_MALLOC_H 0
%define HAVE_OPENCV2_CORE_CORE_C_H 0
%define HAVE_OPENGL_GL3_H 0
%define HAVE_POLL_H 1
%define HAVE_SYS_PARAM_H 1
%define HAVE_SYS_RESOURCE_H 1
%define HAVE_SYS_SELECT_H 1
%define HAVE_SYS_SOUNDCARD_H 0
%define HAVE_SYS_TIME_H 1
%define HAVE_SYS_UN_H 1
%define HAVE_SYS_VIDEOIO_H 0
%define HAVE_TERMIOS_H 1
%define HAVE_UDPLITE_H 0
%define HAVE_UNISTD_H 1
%define HAVE_VALGRIND_VALGRIND_H 0
%define HAVE_WINDOWS_H 0
%define HAVE_WINSOCK2_H 0
%define HAVE_INTRINSICS_NEON 0
%define HAVE_ATANF 1
%define HAVE_ATAN2F 1
%define HAVE_CBRT 1
%define HAVE_CBRTF 1
%define HAVE_COPYSIGN 1
%define HAVE_COSF 1
%define HAVE_ERF 1
%define HAVE_EXP2 1
%define HAVE_EXP2F 1
%define HAVE_EXPF 1
%define HAVE_HYPOT 1
%define HAVE_ISFINITE 1
%define HAVE_ISINF 1
%define HAVE_ISNAN 1
%define HAVE_LDEXPF 1
%define HAVE_LLRINT 1
%define HAVE_LLRINTF 1
%define HAVE_LOG2 1
%define HAVE_LOG2F 1
%define HAVE_LOG10F 1
%define HAVE_LRINT 1
%define HAVE_LRINTF 1
%define HAVE_POWF 1
%define HAVE_RINT 1
%define HAVE_ROUND 1
%define HAVE_ROUNDF 1
%define HAVE_SINF 1
%define HAVE_TRUNC 1
%define HAVE_TRUNCF 1
%define HAVE_DOS_PATHS 0
%define HAVE_LIBC_MSVCRT 0
%define HAVE_MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS 0
%define HAVE_SECTION_DATA_REL_RO 0
%define HAVE_THREADS 1
%define HAVE_UWP 0
%define HAVE_WINRT 0
%define HAVE_ACCESS 1
%define HAVE_ALIGNED_MALLOC 0
%define HAVE_ARC4RANDOM 1
%define HAVE_CLOCK_GETTIME 1
%define HAVE_CLOSESOCKET 0
%define HAVE_COMMANDLINETOARGVW 0
%define HAVE_FCNTL 1
%define HAVE_GETADDRINFO 1
%define HAVE_GETHRTIME 0
%define HAVE_GETOPT 1
%define HAVE_GETPROCESSAFFINITYMASK 0
%define HAVE_GETPROCESSMEMORYINFO 0
%define HAVE_GETPROCESSTIMES 0
%define HAVE_GETRUSAGE 1
%define HAVE_GETSYSTEMTIMEASFILETIME 0
%define HAVE_GETTIMEOFDAY 1
%define HAVE_GLOB 1
%define HAVE_GLXGETPROCADDRESS 0
%define HAVE_GMTIME_R 1
%define HAVE_INET_ATON 1
%define HAVE_ISATTY 1
%define HAVE_KBHIT 0
%define HAVE_LOCALTIME_R 1
%define HAVE_LSTAT 1
%define HAVE_LZO1X_999_COMPRESS 0
%define HAVE_MACH_ABSOLUTE_TIME 1
%define HAVE_MAPVIEWOFFILE 0
%define HAVE_MEMALIGN 0
%define HAVE_MKSTEMP 1
%define HAVE_MMAP 1
%define HAVE_MPROTECT 1
%define HAVE_NANOSLEEP 1
%define HAVE_PEEKNAMEDPIPE 0
%define HAVE_POSIX_MEMALIGN 1
%define HAVE_PTHREAD_CANCEL 1
%define HAVE_SCHED_GETAFFINITY 0
%define HAVE_SECITEMIMPORT 1
%define HAVE_SETCONSOLETEXTATTRIBUTE 0
%define HAVE_SETCONSOLECTRLHANDLER 0
%define HAVE_SETMODE 0
%define HAVE_SETRLIMIT 1
%define HAVE_SLEEP 0
%define HAVE_STRERROR_R 1
%define HAVE_SYSCONF 1
%define HAVE_SYSCTL 1
%define HAVE_USLEEP 1
%define HAVE_UTGETOSTYPEFROMSTRING 1
%define HAVE_VIRTUALALLOC 0
%define HAVE_WGLGETPROCADDRESS 0
%define HAVE_BCRYPT 0
%define HAVE_VAAPI_DRM 0
%define HAVE_VAAPI_X11 0
%define HAVE_VDPAU_X11 0
%define HAVE_PTHREADS 1
%define HAVE_OS2THREADS 0
%define HAVE_W32THREADS 0
%define HAVE_AS_ARCH_DIRECTIVE 0
%define HAVE_AS_DN_DIRECTIVE 0
%define HAVE_AS_FPU_DIRECTIVE 0
%define HAVE_AS_FUNC 0
%define HAVE_AS_OBJECT_ARCH 0
%define HAVE_ASM_MOD_Q 0
%define HAVE_BLOCKS_EXTENSION 1
%define HAVE_EBP_AVAILABLE 1
%define HAVE_EBX_AVAILABLE 1
%define HAVE_GNU_AS 0
%define HAVE_GNU_WINDRES 0
%define HAVE_IBM_ASM 0
%define HAVE_INLINE_ASM_DIRECT_SYMBOL_REFS 1
%define HAVE_INLINE_ASM_LABELS 1
%define HAVE_INLINE_ASM_NONLOCAL_LABELS 1
%define HAVE_PRAGMA_DEPRECATED 1
%define HAVE_RSYNC_CONTIMEOUT 0
%define HAVE_SYMVER_ASM_LABEL 1
%define HAVE_SYMVER_GNU_ASM 0
%define HAVE_VFP_ARGS 0
%define HAVE_XFORM_ASM 0
%define HAVE_XMM_CLOBBERS 1
%define HAVE_KCMVIDEOCODECTYPE_HEVC 1
%define HAVE_KCVPIXELFORMATTYPE_420YPCBCR10BIPLANARVIDEORANGE 1
%define HAVE_SOCKLEN_T 1
%define HAVE_STRUCT_ADDRINFO 1
%define HAVE_STRUCT_GROUP_SOURCE_REQ 1
%define HAVE_STRUCT_IP_MREQ_SOURCE 1
%define HAVE_STRUCT_IPV6_MREQ 1
%define HAVE_STRUCT_MSGHDR_MSG_FLAGS 1
%define HAVE_STRUCT_POLLFD 1
%define HAVE_STRUCT_RUSAGE_RU_MAXRSS 1
%define HAVE_STRUCT_SCTP_EVENT_SUBSCRIBE 0
%define HAVE_STRUCT_SOCKADDR_IN6 1
%define HAVE_STRUCT_SOCKADDR_SA_LEN 1
%define HAVE_STRUCT_SOCKADDR_STORAGE 1
%define HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 0
%define HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE 0
%define HAVE_MAKEINFO 1
%define HAVE_MAKEINFO_HTML 0
%define HAVE_OPENCL_D3D11 0
%define HAVE_OPENCL_DRM_ARM 0
%define HAVE_OPENCL_DRM_BEIGNET 0
%define HAVE_OPENCL_DXVA2 0
%define HAVE_OPENCL_VAAPI_BEIGNET 0
%define HAVE_OPENCL_VAAPI_INTEL_MEDIA 0
%define HAVE_PERL 1
%define HAVE_POD2MAN 1
%define HAVE_TEXI2HTML 0
%define CONFIG_DOC 1
%define CONFIG_HTMLPAGES 0
%define CONFIG_MANPAGES 1
%define CONFIG_PODPAGES 1
%define CONFIG_TXTPAGES 1
%define CONFIG_AVIO_DIR_CMD_EXAMPLE 1
%define CONFIG_AVIO_READING_EXAMPLE 1
%define CONFIG_DECODE_AUDIO_EXAMPLE 1
%define CONFIG_DECODE_VIDEO_EXAMPLE 1
%define CONFIG_DEMUXING_DECODING_EXAMPLE 1
%define CONFIG_ENCODE_AUDIO_EXAMPLE 1
%define CONFIG_ENCODE_VIDEO_EXAMPLE 1
%define CONFIG_EXTRACT_MVS_EXAMPLE 1
%define CONFIG_FILTER_AUDIO_EXAMPLE 1
%define CONFIG_FILTERING_AUDIO_EXAMPLE 1
%define CONFIG_FILTERING_VIDEO_EXAMPLE 1
%define CONFIG_HTTP_MULTICLIENT_EXAMPLE 1
%define CONFIG_HW_DECODE_EXAMPLE 1
%define CONFIG_METADATA_EXAMPLE 1
%define CONFIG_MUXING_EXAMPLE 1
%define CONFIG_QSVDEC_EXAMPLE 0
%define CONFIG_REMUXING_EXAMPLE 1
%define CONFIG_RESAMPLING_AUDIO_EXAMPLE 1
%define CONFIG_SCALING_VIDEO_EXAMPLE 1
%define CONFIG_TRANSCODE_AAC_EXAMPLE 1
%define CONFIG_TRANSCODING_EXAMPLE 1
%define CONFIG_VAAPI_ENCODE_EXAMPLE 0
%define CONFIG_VAAPI_TRANSCODE_EXAMPLE 0
%define CONFIG_AVISYNTH 0
%define CONFIG_FREI0R 0
%define CONFIG_LIBCDIO 0
%define CONFIG_LIBDAVS2 0
%define CONFIG_LIBRUBBERBAND 0
%define CONFIG_LIBVIDSTAB 0
%define CONFIG_LIBX264 0
%define CONFIG_LIBX265 0
%define CONFIG_LIBXAVS 0
%define CONFIG_LIBXAVS2 0
%define CONFIG_LIBXVID 0
%define CONFIG_DECKLINK 0
%define CONFIG_LIBFDK_AAC 0
%define CONFIG_OPENSSL 0
%define CONFIG_LIBTLS 0
%define CONFIG_GMP 0
%define CONFIG_LIBARIBB24 0
%define CONFIG_LIBLENSFUN 0
%define CONFIG_LIBOPENCORE_AMRNB 0
%define CONFIG_LIBOPENCORE_AMRWB 0
%define CONFIG_LIBVMAF 0
%define CONFIG_LIBVO_AMRWBENC 0
%define CONFIG_MBEDTLS 0
%define CONFIG_RKMPP 0
%define CONFIG_LIBSMBCLIENT 0
%define CONFIG_CHROMAPRINT 0
%define CONFIG_GCRYPT 0
%define CONFIG_GNUTLS 0
%define CONFIG_JNI 0
%define CONFIG_LADSPA 0
%define CONFIG_LIBAOM 0
%define CONFIG_LIBASS 0
%define CONFIG_LIBBLURAY 0
%define CONFIG_LIBBS2B 0
%define CONFIG_LIBCACA 0
%define CONFIG_LIBCELT 0
%define CONFIG_LIBCODEC2 0
%define CONFIG_LIBDAV1D 0
%define CONFIG_LIBDC1394 0
%define CONFIG_LIBDRM 0
%define CONFIG_LIBFLITE 0
%define CONFIG_LIBFONTCONFIG 0
%define CONFIG_LIBFREETYPE 0
%define CONFIG_LIBFRIBIDI 0
%define CONFIG_LIBGME 0
%define CONFIG_LIBGSM 0
%define CONFIG_LIBIEC61883 0
%define CONFIG_LIBILBC 0
%define CONFIG_LIBJACK 0
%define CONFIG_LIBKLVANC 0
%define CONFIG_LIBKVAZAAR 0
%define CONFIG_LIBMODPLUG 0
%define CONFIG_LIBMP3LAME 0
%define CONFIG_LIBMYSOFA 0
%define CONFIG_LIBOPENCV 0
%define CONFIG_LIBOPENH264 0
%define CONFIG_LIBOPENJPEG 0
%define CONFIG_LIBOPENMPT 0
%define CONFIG_LIBOPUS 0
%define CONFIG_LIBPULSE 0
%define CONFIG_LIBRSVG 0
%define CONFIG_LIBRTMP 0
%define CONFIG_LIBSHINE 0
%define CONFIG_LIBSMBCLIENT 0
%define CONFIG_LIBSNAPPY 0
%define CONFIG_LIBSOXR 0
%define CONFIG_LIBSPEEX 0
%define CONFIG_LIBSRT 0
%define CONFIG_LIBSSH 0
%define CONFIG_LIBTENSORFLOW 0
%define CONFIG_LIBTESSERACT 0
%define CONFIG_LIBTHEORA 0
%define CONFIG_LIBTWOLAME 0
%define CONFIG_LIBV4L2 0
%define CONFIG_LIBVORBIS 0
%define CONFIG_LIBVPX 0
%define CONFIG_LIBWAVPACK 0
%define CONFIG_LIBWEBP 0
%define CONFIG_LIBXML2 0
%define CONFIG_LIBZIMG 0
%define CONFIG_LIBZMQ 0
%define CONFIG_LIBZVBI 0
%define CONFIG_LV2 0
%define CONFIG_MEDIACODEC 0
%define CONFIG_OPENAL 0
%define CONFIG_OPENGL 0
%define CONFIG_POCKETSPHINX 0
%define CONFIG_VAPOURSYNTH 0
%define CONFIG_ALSA 0
%define CONFIG_APPKIT 1
%define CONFIG_AVFOUNDATION 1
%define CONFIG_BZLIB 1
%define CONFIG_COREIMAGE 1
%define CONFIG_ICONV 1
%define CONFIG_LIBXCB 0
%define CONFIG_LIBXCB_SHM 0
%define CONFIG_LIBXCB_SHAPE 0
%define CONFIG_LIBXCB_XFIXES 0
%define CONFIG_LZMA 1
%define CONFIG_SCHANNEL 0
%define CONFIG_SDL2 0
%define CONFIG_SECURETRANSPORT 1
%define CONFIG_SNDIO 0
%define CONFIG_XLIB 0
%define CONFIG_ZLIB 1
%define CONFIG_CUDA_NVCC 0
%define CONFIG_CUDA_SDK 0
%define CONFIG_LIBNPP 0
%define CONFIG_LIBMFX 0
%define CONFIG_MMAL 0
%define CONFIG_OMX 0
%define CONFIG_OPENCL 0
%define CONFIG_AMF 0
%define CONFIG_AUDIOTOOLBOX 1
%define CONFIG_CRYSTALHD 0
%define CONFIG_CUDA 0
%define CONFIG_CUDA_LLVM 0
%define CONFIG_CUVID 0
%define CONFIG_D3D11VA 0
%define CONFIG_DXVA2 0
%define CONFIG_FFNVCODEC 0
%define CONFIG_NVDEC 0
%define CONFIG_NVENC 0
%define CONFIG_VAAPI 0
%define CONFIG_VDPAU 0
%define CONFIG_VIDEOTOOLBOX 1
%define CONFIG_V4L2_M2M 0
%define CONFIG_XVMC 0
%define CONFIG_FTRAPV 0
%define CONFIG_GRAY 0
%define CONFIG_HARDCODED_TABLES 0
%define CONFIG_OMX_RPI 0
%define CONFIG_RUNTIME_CPUDETECT 1
%define CONFIG_SAFE_BITSTREAM_READER 1
%define CONFIG_SHARED 0
%define CONFIG_SMALL 0
%define CONFIG_STATIC 1
%define CONFIG_SWSCALE_ALPHA 1
%define CONFIG_GPL 0
%define CONFIG_NONFREE 0
%define CONFIG_VERSION3 0
%define CONFIG_AVDEVICE 1
%define CONFIG_AVFILTER 1
%define CONFIG_SWSCALE 1
%define CONFIG_POSTPROC 0
%define CONFIG_AVFORMAT 1
%define CONFIG_AVCODEC 1
%define CONFIG_SWRESAMPLE 1
%define CONFIG_AVRESAMPLE 0
%define CONFIG_AVUTIL 1
%define CONFIG_FFPLAY 1
%define CONFIG_FFPROBE 1
%define CONFIG_FFMPEG 1
%define CONFIG_DCT 1
%define CONFIG_DWT 1
%define CONFIG_ERROR_RESILIENCE 1
%define CONFIG_FAAN 1
%define CONFIG_FAST_UNALIGNED 1
%define CONFIG_FFT 1
%define CONFIG_LSP 1
%define CONFIG_LZO 1
%define CONFIG_MDCT 1
%define CONFIG_PIXELUTILS 1
%define CONFIG_NETWORK 1
%define CONFIG_RDFT 1
%define CONFIG_AUTODETECT 0
%define CONFIG_FONTCONFIG 0
%define CONFIG_LINUX_PERF 0
%define CONFIG_MEMORY_POISONING 0
%define CONFIG_NEON_CLOBBER_TEST 0
%define CONFIG_OSSFUZZ 0
%define CONFIG_PIC 1
%define CONFIG_THUMB 0
%define CONFIG_VALGRIND_BACKTRACE 0
%define CONFIG_XMM_CLOBBER_TEST 0
%define CONFIG_BSFS 1
%define CONFIG_DECODERS 1
%define CONFIG_ENCODERS 1
%define CONFIG_HWACCELS 1
%define CONFIG_PARSERS 1
%define CONFIG_INDEVS 1
%define CONFIG_OUTDEVS 1
%define CONFIG_FILTERS 1
%define CONFIG_DEMUXERS 1
%define CONFIG_MUXERS 1
%define CONFIG_PROTOCOLS 1
%define CONFIG_AANDCTTABLES 1
%define CONFIG_AC3DSP 1
%define CONFIG_ADTS_HEADER 1
%define CONFIG_AUDIO_FRAME_QUEUE 1
%define CONFIG_AUDIODSP 1
%define CONFIG_BLOCKDSP 1
%define CONFIG_BSWAPDSP 1
%define CONFIG_CABAC 1
%define CONFIG_CBS 1
%define CONFIG_CBS_AV1 1
%define CONFIG_CBS_H264 1
%define CONFIG_CBS_H265 1
%define CONFIG_CBS_JPEG 0
%define CONFIG_CBS_MPEG2 1
%define CONFIG_CBS_VP9 1
%define CONFIG_DIRAC_PARSE 1
%define CONFIG_DNN 1
%define CONFIG_DVPROFILE 1
%define CONFIG_EXIF 1
%define CONFIG_FAANDCT 1
%define CONFIG_FAANIDCT 1
%define CONFIG_FDCTDSP 1
%define CONFIG_FLACDSP 1
%define CONFIG_FMTCONVERT 1
%define CONFIG_FRAME_THREAD_ENCODER 1
%define CONFIG_G722DSP 1
%define CONFIG_GOLOMB 1
%define CONFIG_GPLV3 0
%define CONFIG_H263DSP 1
%define CONFIG_H264CHROMA 1
%define CONFIG_H264DSP 1
%define CONFIG_H264PARSE 1
%define CONFIG_H264PRED 1
%define CONFIG_H264QPEL 1
%define CONFIG_HEVCPARSE 1
%define CONFIG_HPELDSP 1
%define CONFIG_HUFFMAN 1
%define CONFIG_HUFFYUVDSP 1
%define CONFIG_HUFFYUVENCDSP 1
%define CONFIG_IDCTDSP 1
%define CONFIG_IIRFILTER 1
%define CONFIG_MDCT15 1
%define CONFIG_INTRAX8 1
%define CONFIG_ISO_MEDIA 1
%define CONFIG_IVIDSP 1
%define CONFIG_JPEGTABLES 1
%define CONFIG_LGPLV3 0
%define CONFIG_LIBX262 0
%define CONFIG_LLAUDDSP 1
%define CONFIG_LLVIDDSP 1
%define CONFIG_LLVIDENCDSP 1
%define CONFIG_LPC 1
%define CONFIG_LZF 1
%define CONFIG_ME_CMP 1
%define CONFIG_MPEG_ER 1
%define CONFIG_MPEGAUDIO 1
%define CONFIG_MPEGAUDIODSP 1
%define CONFIG_MPEGAUDIOHEADER 1
%define CONFIG_MPEGVIDEO 1
%define CONFIG_MPEGVIDEOENC 1
%define CONFIG_MSS34DSP 1
%define CONFIG_PIXBLOCKDSP 1
%define CONFIG_QPELDSP 1
%define CONFIG_QSV 0
%define CONFIG_QSVDEC 0
%define CONFIG_QSVENC 0
%define CONFIG_QSVVPP 0
%define CONFIG_RANGECODER 1
%define CONFIG_RIFFDEC 1
%define CONFIG_RIFFENC 1
%define CONFIG_RTPDEC 1
%define CONFIG_RTPENC_CHAIN 1
%define CONFIG_RV34DSP 1
%define CONFIG_SCENE_SAD 1
%define CONFIG_SINEWIN 1
%define CONFIG_SNAPPY 1
%define CONFIG_SRTP 1
%define CONFIG_STARTCODE 1
%define CONFIG_TEXTUREDSP 1
%define CONFIG_TEXTUREDSPENC 0
%define CONFIG_TPELDSP 1
%define CONFIG_VAAPI_1 0
%define CONFIG_VAAPI_ENCODE 0
%define CONFIG_VC1DSP 1
%define CONFIG_VIDEODSP 1
%define CONFIG_VP3DSP 1
%define CONFIG_VP56DSP 1
%define CONFIG_VP8DSP 1
%define CONFIG_WMA_FREQS 1
%define CONFIG_WMV2DSP 1
%define CONFIG_AAC_ADTSTOASC_BSF 1
%define CONFIG_AV1_FRAME_SPLIT_BSF 1
%define CONFIG_AV1_METADATA_BSF 1
%define CONFIG_CHOMP_BSF 1
%define CONFIG_DUMP_EXTRADATA_BSF 1
%define CONFIG_DCA_CORE_BSF 1
%define CONFIG_EAC3_CORE_BSF 1
%define CONFIG_EXTRACT_EXTRADATA_BSF 1
%define CONFIG_FILTER_UNITS_BSF 1
%define CONFIG_H264_METADATA_BSF 1
%define CONFIG_H264_MP4TOANNEXB_BSF 1
%define CONFIG_H264_REDUNDANT_PPS_BSF 1
%define CONFIG_HAPQA_EXTRACT_BSF 1
%define CONFIG_HEVC_METADATA_BSF 1
%define CONFIG_HEVC_MP4TOANNEXB_BSF 1
%define CONFIG_IMX_DUMP_HEADER_BSF 1
%define CONFIG_MJPEG2JPEG_BSF 1
%define CONFIG_MJPEGA_DUMP_HEADER_BSF 1
%define CONFIG_MP3_HEADER_DECOMPRESS_BSF 1
%define CONFIG_MPEG2_METADATA_BSF 1
%define CONFIG_MPEG4_UNPACK_BFRAMES_BSF 1
%define CONFIG_MOV2TEXTSUB_BSF 1
%define CONFIG_NOISE_BSF 1
%define CONFIG_NULL_BSF 1
%define CONFIG_PRORES_METADATA_BSF 1
%define CONFIG_REMOVE_EXTRADATA_BSF 1
%define CONFIG_TEXT2MOVSUB_BSF 1
%define CONFIG_TRACE_HEADERS_BSF 1
%define CONFIG_TRUEHD_CORE_BSF 1
%define CONFIG_VP9_METADATA_BSF 1
%define CONFIG_VP9_RAW_REORDER_BSF 1
%define CONFIG_VP9_SUPERFRAME_BSF 1
%define CONFIG_VP9_SUPERFRAME_SPLIT_BSF 1
%define CONFIG_AASC_DECODER 1
%define CONFIG_AIC_DECODER 1
%define CONFIG_ALIAS_PIX_DECODER 1
%define CONFIG_AGM_DECODER 1
%define CONFIG_AMV_DECODER 1
%define CONFIG_ANM_DECODER 1
%define CONFIG_ANSI_DECODER 1
%define CONFIG_APNG_DECODER 1
%define CONFIG_ARBC_DECODER 1
%define CONFIG_ASV1_DECODER 1
%define CONFIG_ASV2_DECODER 1
%define CONFIG_AURA_DECODER 1
%define CONFIG_AURA2_DECODER 1
%define CONFIG_AVRP_DECODER 1
%define CONFIG_AVRN_DECODER 1
%define CONFIG_AVS_DECODER 1
%define CONFIG_AVUI_DECODER 1
%define CONFIG_AYUV_DECODER 1
%define CONFIG_BETHSOFTVID_DECODER 1
%define CONFIG_BFI_DECODER 1
%define CONFIG_BINK_DECODER 1
%define CONFIG_BITPACKED_DECODER 1
%define CONFIG_BMP_DECODER 1
%define CONFIG_BMV_VIDEO_DECODER 1
%define CONFIG_BRENDER_PIX_DECODER 1
%define CONFIG_C93_DECODER 1
%define CONFIG_CAVS_DECODER 1
%define CONFIG_CDGRAPHICS_DECODER 1
%define CONFIG_CDXL_DECODER 1
%define CONFIG_CFHD_DECODER 1
%define CONFIG_CINEPAK_DECODER 1
%define CONFIG_CLEARVIDEO_DECODER 1
%define CONFIG_CLJR_DECODER 1
%define CONFIG_CLLC_DECODER 1
%define CONFIG_COMFORTNOISE_DECODER 1
%define CONFIG_CPIA_DECODER 1
%define CONFIG_CSCD_DECODER 1
%define CONFIG_CYUV_DECODER 1
%define CONFIG_DDS_DECODER 1
%define CONFIG_DFA_DECODER 1
%define CONFIG_DIRAC_DECODER 1
%define CONFIG_DNXHD_DECODER 1
%define CONFIG_DPX_DECODER 1
%define CONFIG_DSICINVIDEO_DECODER 1
%define CONFIG_DVAUDIO_DECODER 1
%define CONFIG_DVVIDEO_DECODER 1
%define CONFIG_DXA_DECODER 1
%define CONFIG_DXTORY_DECODER 1
%define CONFIG_DXV_DECODER 1
%define CONFIG_EACMV_DECODER 1
%define CONFIG_EAMAD_DECODER 1
%define CONFIG_EATGQ_DECODER 1
%define CONFIG_EATGV_DECODER 1
%define CONFIG_EATQI_DECODER 1
%define CONFIG_EIGHTBPS_DECODER 1
%define CONFIG_EIGHTSVX_EXP_DECODER 1
%define CONFIG_EIGHTSVX_FIB_DECODER 1
%define CONFIG_ESCAPE124_DECODER 1
%define CONFIG_ESCAPE130_DECODER 1
%define CONFIG_EXR_DECODER 1
%define CONFIG_FFV1_DECODER 1
%define CONFIG_FFVHUFF_DECODER 1
%define CONFIG_FIC_DECODER 1
%define CONFIG_FITS_DECODER 1
%define CONFIG_FLASHSV_DECODER 1
%define CONFIG_FLASHSV2_DECODER 1
%define CONFIG_FLIC_DECODER 1
%define CONFIG_FLV_DECODER 1
%define CONFIG_FMVC_DECODER 1
%define CONFIG_FOURXM_DECODER 1
%define CONFIG_FRAPS_DECODER 1
%define CONFIG_FRWU_DECODER 1
%define CONFIG_G2M_DECODER 1
%define CONFIG_GDV_DECODER 1
%define CONFIG_GIF_DECODER 1
%define CONFIG_H261_DECODER 1
%define CONFIG_H263_DECODER 1
%define CONFIG_H263I_DECODER 1
%define CONFIG_H263P_DECODER 1
%define CONFIG_H263_V4L2M2M_DECODER 0
%define CONFIG_H264_DECODER 1
%define CONFIG_H264_CRYSTALHD_DECODER 0
%define CONFIG_H264_V4L2M2M_DECODER 0
%define CONFIG_H264_MEDIACODEC_DECODER 0
%define CONFIG_H264_MMAL_DECODER 0
%define CONFIG_H264_QSV_DECODER 0
%define CONFIG_H264_RKMPP_DECODER 0
%define CONFIG_HAP_DECODER 1
%define CONFIG_HEVC_DECODER 1
%define CONFIG_HEVC_QSV_DECODER 0
%define CONFIG_HEVC_RKMPP_DECODER 0
%define CONFIG_HEVC_V4L2M2M_DECODER 0
%define CONFIG_HNM4_VIDEO_DECODER 1
%define CONFIG_HQ_HQA_DECODER 1
%define CONFIG_HQX_DECODER 1
%define CONFIG_HUFFYUV_DECODER 1
%define CONFIG_HYMT_DECODER 1
%define CONFIG_IDCIN_DECODER 1
%define CONFIG_IFF_ILBM_DECODER 1
%define CONFIG_IMM4_DECODER 1
%define CONFIG_INDEO2_DECODER 1
%define CONFIG_INDEO3_DECODER 1
%define CONFIG_INDEO4_DECODER 1
%define CONFIG_INDEO5_DECODER 1
%define CONFIG_INTERPLAY_VIDEO_DECODER 1
%define CONFIG_JPEG2000_DECODER 1
%define CONFIG_JPEGLS_DECODER 1
%define CONFIG_JV_DECODER 1
%define CONFIG_KGV1_DECODER 1
%define CONFIG_KMVC_DECODER 1
%define CONFIG_LAGARITH_DECODER 1
%define CONFIG_LOCO_DECODER 1
%define CONFIG_LSCR_DECODER 1
%define CONFIG_M101_DECODER 1
%define CONFIG_MAGICYUV_DECODER 1
%define CONFIG_MDEC_DECODER 1
%define CONFIG_MIMIC_DECODER 1
%define CONFIG_MJPEG_DECODER 1
%define CONFIG_MJPEGB_DECODER 1
%define CONFIG_MMVIDEO_DECODER 1
%define CONFIG_MOTIONPIXELS_DECODER 1
%define CONFIG_MPEG1VIDEO_DECODER 1
%define CONFIG_MPEG2VIDEO_DECODER 1
%define CONFIG_MPEG4_DECODER 1
%define CONFIG_MPEG4_CRYSTALHD_DECODER 0
%define CONFIG_MPEG4_V4L2M2M_DECODER 0
%define CONFIG_MPEG4_MMAL_DECODER 0
%define CONFIG_MPEGVIDEO_DECODER 1
%define CONFIG_MPEG1_V4L2M2M_DECODER 0
%define CONFIG_MPEG2_MMAL_DECODER 0
%define CONFIG_MPEG2_CRYSTALHD_DECODER 0
%define CONFIG_MPEG2_V4L2M2M_DECODER 0
%define CONFIG_MPEG2_QSV_DECODER 0
%define CONFIG_MPEG2_MEDIACODEC_DECODER 0
%define CONFIG_MSA1_DECODER 1
%define CONFIG_MSCC_DECODER 1
%define CONFIG_MSMPEG4V1_DECODER 1
%define CONFIG_MSMPEG4V2_DECODER 1
%define CONFIG_MSMPEG4V3_DECODER 1
%define CONFIG_MSMPEG4_CRYSTALHD_DECODER 0
%define CONFIG_MSRLE_DECODER 1
%define CONFIG_MSS1_DECODER 1
%define CONFIG_MSS2_DECODER 1
%define CONFIG_MSVIDEO1_DECODER 1
%define CONFIG_MSZH_DECODER 1
%define CONFIG_MTS2_DECODER 1
%define CONFIG_MVC1_DECODER 1
%define CONFIG_MVC2_DECODER 1
%define CONFIG_MWSC_DECODER 1
%define CONFIG_MXPEG_DECODER 1
%define CONFIG_NUV_DECODER 1
%define CONFIG_PAF_VIDEO_DECODER 1
%define CONFIG_PAM_DECODER 1
%define CONFIG_PBM_DECODER 1
%define CONFIG_PCX_DECODER 1
%define CONFIG_PGM_DECODER 1
%define CONFIG_PGMYUV_DECODER 1
%define CONFIG_PICTOR_DECODER 1
%define CONFIG_PIXLET_DECODER 1
%define CONFIG_PNG_DECODER 1
%define CONFIG_PPM_DECODER 1
%define CONFIG_PRORES_DECODER 1
%define CONFIG_PROSUMER_DECODER 1
%define CONFIG_PSD_DECODER 1
%define CONFIG_PTX_DECODER 1
%define CONFIG_QDRAW_DECODER 1
%define CONFIG_QPEG_DECODER 1
%define CONFIG_QTRLE_DECODER 1
%define CONFIG_R10K_DECODER 1
%define CONFIG_R210_DECODER 1
%define CONFIG_RASC_DECODER 1
%define CONFIG_RAWVIDEO_DECODER 1
%define CONFIG_RL2_DECODER 1
%define CONFIG_ROQ_DECODER 1
%define CONFIG_RPZA_DECODER 1
%define CONFIG_RSCC_DECODER 1
%define CONFIG_RV10_DECODER 1
%define CONFIG_RV20_DECODER 1
%define CONFIG_RV30_DECODER 1
%define CONFIG_RV40_DECODER 1
%define CONFIG_S302M_DECODER 1
%define CONFIG_SANM_DECODER 1
%define CONFIG_SCPR_DECODER 1
%define CONFIG_SCREENPRESSO_DECODER 1
%define CONFIG_SDX2_DPCM_DECODER 1
%define CONFIG_SGI_DECODER 1
%define CONFIG_SGIRLE_DECODER 1
%define CONFIG_SHEERVIDEO_DECODER 1
%define CONFIG_SMACKER_DECODER 1
%define CONFIG_SMC_DECODER 1
%define CONFIG_SMVJPEG_DECODER 1
%define CONFIG_SNOW_DECODER 1
%define CONFIG_SP5X_DECODER 1
%define CONFIG_SPEEDHQ_DECODER 1
%define CONFIG_SRGC_DECODER 1
%define CONFIG_SUNRAST_DECODER 1
%define CONFIG_SVQ1_DECODER 1
%define CONFIG_SVQ3_DECODER 1
%define CONFIG_TARGA_DECODER 1
%define CONFIG_TARGA_Y216_DECODER 1
%define CONFIG_TDSC_DECODER 1
%define CONFIG_THEORA_DECODER 1
%define CONFIG_THP_DECODER 1
%define CONFIG_TIERTEXSEQVIDEO_DECODER 1
%define CONFIG_TIFF_DECODER 1
%define CONFIG_TMV_DECODER 1
%define CONFIG_TRUEMOTION1_DECODER 1
%define CONFIG_TRUEMOTION2_DECODER 1
%define CONFIG_TRUEMOTION2RT_DECODER 1
%define CONFIG_TSCC_DECODER 1
%define CONFIG_TSCC2_DECODER 1
%define CONFIG_TXD_DECODER 1
%define CONFIG_ULTI_DECODER 1
%define CONFIG_UTVIDEO_DECODER 1
%define CONFIG_V210_DECODER 1
%define CONFIG_V210X_DECODER 1
%define CONFIG_V308_DECODER 1
%define CONFIG_V408_DECODER 1
%define CONFIG_V410_DECODER 1
%define CONFIG_VB_DECODER 1
%define CONFIG_VBLE_DECODER 1
%define CONFIG_VC1_DECODER 1
%define CONFIG_VC1_CRYSTALHD_DECODER 0
%define CONFIG_VC1IMAGE_DECODER 1
%define CONFIG_VC1_MMAL_DECODER 0
%define CONFIG_VC1_QSV_DECODER 0
%define CONFIG_VC1_V4L2M2M_DECODER 0
%define CONFIG_VCR1_DECODER 1
%define CONFIG_VMDVIDEO_DECODER 1
%define CONFIG_VMNC_DECODER 1
%define CONFIG_VP3_DECODER 1
%define CONFIG_VP4_DECODER 1
%define CONFIG_VP5_DECODER 1
%define CONFIG_VP6_DECODER 1
%define CONFIG_VP6A_DECODER 1
%define CONFIG_VP6F_DECODER 1
%define CONFIG_VP7_DECODER 1
%define CONFIG_VP8_DECODER 1
%define CONFIG_VP8_RKMPP_DECODER 0
%define CONFIG_VP8_V4L2M2M_DECODER 0
%define CONFIG_VP9_DECODER 1
%define CONFIG_VP9_RKMPP_DECODER 0
%define CONFIG_VP9_V4L2M2M_DECODER 0
%define CONFIG_VQA_DECODER 1
%define CONFIG_WEBP_DECODER 1
%define CONFIG_WCMV_DECODER 1
%define CONFIG_WRAPPED_AVFRAME_DECODER 1
%define CONFIG_WMV1_DECODER 1
%define CONFIG_WMV2_DECODER 1
%define CONFIG_WMV3_DECODER 1
%define CONFIG_WMV3_CRYSTALHD_DECODER 0
%define CONFIG_WMV3IMAGE_DECODER 1
%define CONFIG_WNV1_DECODER 1
%define CONFIG_XAN_WC3_DECODER 1
%define CONFIG_XAN_WC4_DECODER 1
%define CONFIG_XBM_DECODER 1
%define CONFIG_XFACE_DECODER 1
%define CONFIG_XL_DECODER 1
%define CONFIG_XPM_DECODER 1
%define CONFIG_XWD_DECODER 1
%define CONFIG_Y41P_DECODER 1
%define CONFIG_YLC_DECODER 1
%define CONFIG_YOP_DECODER 1
%define CONFIG_YUV4_DECODER 1
%define CONFIG_ZERO12V_DECODER 1
%define CONFIG_ZEROCODEC_DECODER 1
%define CONFIG_ZLIB_DECODER 1
%define CONFIG_ZMBV_DECODER 1
%define CONFIG_AAC_DECODER 1
%define CONFIG_AAC_FIXED_DECODER 1
%define CONFIG_AAC_LATM_DECODER 1
%define CONFIG_AC3_DECODER 1
%define CONFIG_AC3_FIXED_DECODER 1
%define CONFIG_ALAC_DECODER 1
%define CONFIG_ALS_DECODER 1
%define CONFIG_AMRNB_DECODER 1
%define CONFIG_AMRWB_DECODER 1
%define CONFIG_APE_DECODER 1
%define CONFIG_APTX_DECODER 1
%define CONFIG_APTX_HD_DECODER 1
%define CONFIG_ATRAC1_DECODER 1
%define CONFIG_ATRAC3_DECODER 1
%define CONFIG_ATRAC3AL_DECODER 1
%define CONFIG_ATRAC3P_DECODER 1
%define CONFIG_ATRAC3PAL_DECODER 1
%define CONFIG_ATRAC9_DECODER 1
%define CONFIG_BINKAUDIO_DCT_DECODER 1
%define CONFIG_BINKAUDIO_RDFT_DECODER 1
%define CONFIG_BMV_AUDIO_DECODER 1
%define CONFIG_COOK_DECODER 1
%define CONFIG_DCA_DECODER 1
%define CONFIG_DOLBY_E_DECODER 1
%define CONFIG_DSD_LSBF_DECODER 1
%define CONFIG_DSD_MSBF_DECODER 1
%define CONFIG_DSD_LSBF_PLANAR_DECODER 1
%define CONFIG_DSD_MSBF_PLANAR_DECODER 1
%define CONFIG_DSICINAUDIO_DECODER 1
%define CONFIG_DSS_SP_DECODER 1
%define CONFIG_DST_DECODER 1
%define CONFIG_EAC3_DECODER 1
%define CONFIG_EVRC_DECODER 1
%define CONFIG_FFWAVESYNTH_DECODER 1
%define CONFIG_FLAC_DECODER 1
%define CONFIG_G723_1_DECODER 1
%define CONFIG_G729_DECODER 1
%define CONFIG_GSM_DECODER 1
%define CONFIG_GSM_MS_DECODER 1
%define CONFIG_HCOM_DECODER 1
%define CONFIG_IAC_DECODER 1
%define CONFIG_ILBC_DECODER 1
%define CONFIG_IMC_DECODER 1
%define CONFIG_INTERPLAY_ACM_DECODER 1
%define CONFIG_MACE3_DECODER 1
%define CONFIG_MACE6_DECODER 1
%define CONFIG_METASOUND_DECODER 1
%define CONFIG_MLP_DECODER 1
%define CONFIG_MP1_DECODER 1
%define CONFIG_MP1FLOAT_DECODER 1
%define CONFIG_MP2_DECODER 1
%define CONFIG_MP2FLOAT_DECODER 1
%define CONFIG_MP3FLOAT_DECODER 1
%define CONFIG_MP3_DECODER 1
%define CONFIG_MP3ADUFLOAT_DECODER 1
%define CONFIG_MP3ADU_DECODER 1
%define CONFIG_MP3ON4FLOAT_DECODER 1
%define CONFIG_MP3ON4_DECODER 1
%define CONFIG_MPC7_DECODER 1
%define CONFIG_MPC8_DECODER 1
%define CONFIG_NELLYMOSER_DECODER 1
%define CONFIG_ON2AVC_DECODER 1
%define CONFIG_OPUS_DECODER 1
%define CONFIG_PAF_AUDIO_DECODER 1
%define CONFIG_QCELP_DECODER 1
%define CONFIG_QDM2_DECODER 1
%define CONFIG_QDMC_DECODER 1
%define CONFIG_RA_144_DECODER 1
%define CONFIG_RA_288_DECODER 1
%define CONFIG_RALF_DECODER 1
%define CONFIG_SBC_DECODER 1
%define CONFIG_SHORTEN_DECODER 1
%define CONFIG_SIPR_DECODER 1
%define CONFIG_SMACKAUD_DECODER 1
%define CONFIG_SONIC_DECODER 1
%define CONFIG_TAK_DECODER 1
%define CONFIG_TRUEHD_DECODER 1
%define CONFIG_TRUESPEECH_DECODER 1
%define CONFIG_TTA_DECODER 1
%define CONFIG_TWINVQ_DECODER 1
%define CONFIG_VMDAUDIO_DECODER 1
%define CONFIG_VORBIS_DECODER 1
%define CONFIG_WAVPACK_DECODER 1
%define CONFIG_WMALOSSLESS_DECODER 1
%define CONFIG_WMAPRO_DECODER 1
%define CONFIG_WMAV1_DECODER 1
%define CONFIG_WMAV2_DECODER 1
%define CONFIG_WMAVOICE_DECODER 1
%define CONFIG_WS_SND1_DECODER 1
%define CONFIG_XMA1_DECODER 1
%define CONFIG_XMA2_DECODER 1
%define CONFIG_PCM_ALAW_DECODER 1
%define CONFIG_PCM_BLURAY_DECODER 1
%define CONFIG_PCM_DVD_DECODER 1
%define CONFIG_PCM_F16LE_DECODER 1
%define CONFIG_PCM_F24LE_DECODER 1
%define CONFIG_PCM_F32BE_DECODER 1
%define CONFIG_PCM_F32LE_DECODER 1
%define CONFIG_PCM_F64BE_DECODER 1
%define CONFIG_PCM_F64LE_DECODER 1
%define CONFIG_PCM_LXF_DECODER 1
%define CONFIG_PCM_MULAW_DECODER 1
%define CONFIG_PCM_S8_DECODER 1
%define CONFIG_PCM_S8_PLANAR_DECODER 1
%define CONFIG_PCM_S16BE_DECODER 1
%define CONFIG_PCM_S16BE_PLANAR_DECODER 1
%define CONFIG_PCM_S16LE_DECODER 1
%define CONFIG_PCM_S16LE_PLANAR_DECODER 1
%define CONFIG_PCM_S24BE_DECODER 1
%define CONFIG_PCM_S24DAUD_DECODER 1
%define CONFIG_PCM_S24LE_DECODER 1
%define CONFIG_PCM_S24LE_PLANAR_DECODER 1
%define CONFIG_PCM_S32BE_DECODER 1
%define CONFIG_PCM_S32LE_DECODER 1
%define CONFIG_PCM_S32LE_PLANAR_DECODER 1
%define CONFIG_PCM_S64BE_DECODER 1
%define CONFIG_PCM_S64LE_DECODER 1
%define CONFIG_PCM_U8_DECODER 1
%define CONFIG_PCM_U16BE_DECODER 1
%define CONFIG_PCM_U16LE_DECODER 1
%define CONFIG_PCM_U24BE_DECODER 1
%define CONFIG_PCM_U24LE_DECODER 1
%define CONFIG_PCM_U32BE_DECODER 1
%define CONFIG_PCM_U32LE_DECODER 1
%define CONFIG_PCM_VIDC_DECODER 1
%define CONFIG_PCM_ZORK_DECODER 1
%define CONFIG_GREMLIN_DPCM_DECODER 1
%define CONFIG_INTERPLAY_DPCM_DECODER 1
%define CONFIG_ROQ_DPCM_DECODER 1
%define CONFIG_SOL_DPCM_DECODER 1
%define CONFIG_XAN_DPCM_DECODER 1
%define CONFIG_ADPCM_4XM_DECODER 1
%define CONFIG_ADPCM_ADX_DECODER 1
%define CONFIG_ADPCM_AFC_DECODER 1
%define CONFIG_ADPCM_AGM_DECODER 1
%define CONFIG_ADPCM_AICA_DECODER 1
%define CONFIG_ADPCM_CT_DECODER 1
%define CONFIG_ADPCM_DTK_DECODER 1
%define CONFIG_ADPCM_EA_DECODER 1
%define CONFIG_ADPCM_EA_MAXIS_XA_DECODER 1
%define CONFIG_ADPCM_EA_R1_DECODER 1
%define CONFIG_ADPCM_EA_R2_DECODER 1
%define CONFIG_ADPCM_EA_R3_DECODER 1
%define CONFIG_ADPCM_EA_XAS_DECODER 1
%define CONFIG_ADPCM_G722_DECODER 1
%define CONFIG_ADPCM_G726_DECODER 1
%define CONFIG_ADPCM_G726LE_DECODER 1
%define CONFIG_ADPCM_IMA_AMV_DECODER 1
%define CONFIG_ADPCM_IMA_APC_DECODER 1
%define CONFIG_ADPCM_IMA_DAT4_DECODER 1
%define CONFIG_ADPCM_IMA_DK3_DECODER 1
%define CONFIG_ADPCM_IMA_DK4_DECODER 1
%define CONFIG_ADPCM_IMA_EA_EACS_DECODER 1
%define CONFIG_ADPCM_IMA_EA_SEAD_DECODER 1
%define CONFIG_ADPCM_IMA_ISS_DECODER 1
%define CONFIG_ADPCM_IMA_OKI_DECODER 1
%define CONFIG_ADPCM_IMA_QT_DECODER 1
%define CONFIG_ADPCM_IMA_RAD_DECODER 1
%define CONFIG_ADPCM_IMA_SMJPEG_DECODER 1
%define CONFIG_ADPCM_IMA_WAV_DECODER 1
%define CONFIG_ADPCM_IMA_WS_DECODER 1
%define CONFIG_ADPCM_MS_DECODER 1
%define CONFIG_ADPCM_MTAF_DECODER 1
%define CONFIG_ADPCM_PSX_DECODER 1
%define CONFIG_ADPCM_SBPRO_2_DECODER 1
%define CONFIG_ADPCM_SBPRO_3_DECODER 1
%define CONFIG_ADPCM_SBPRO_4_DECODER 1
%define CONFIG_ADPCM_SWF_DECODER 1
%define CONFIG_ADPCM_THP_DECODER 1
%define CONFIG_ADPCM_THP_LE_DECODER 1
%define CONFIG_ADPCM_VIMA_DECODER 1
%define CONFIG_ADPCM_XA_DECODER 1
%define CONFIG_ADPCM_YAMAHA_DECODER 1
%define CONFIG_SSA_DECODER 1
%define CONFIG_ASS_DECODER 1
%define CONFIG_CCAPTION_DECODER 1
%define CONFIG_DVBSUB_DECODER 1
%define CONFIG_DVDSUB_DECODER 1
%define CONFIG_JACOSUB_DECODER 1
%define CONFIG_MICRODVD_DECODER 1
%define CONFIG_MOVTEXT_DECODER 1
%define CONFIG_MPL2_DECODER 1
%define CONFIG_PGSSUB_DECODER 1
%define CONFIG_PJS_DECODER 1
%define CONFIG_REALTEXT_DECODER 1
%define CONFIG_SAMI_DECODER 1
%define CONFIG_SRT_DECODER 1
%define CONFIG_STL_DECODER 1
%define CONFIG_SUBRIP_DECODER 1
%define CONFIG_SUBVIEWER_DECODER 1
%define CONFIG_SUBVIEWER1_DECODER 1
%define CONFIG_TEXT_DECODER 1
%define CONFIG_VPLAYER_DECODER 1
%define CONFIG_WEBVTT_DECODER 1
%define CONFIG_XSUB_DECODER 1
%define CONFIG_AAC_AT_DECODER 1
%define CONFIG_AC3_AT_DECODER 1
%define CONFIG_ADPCM_IMA_QT_AT_DECODER 1
%define CONFIG_ALAC_AT_DECODER 1
%define CONFIG_AMR_NB_AT_DECODER 1
%define CONFIG_EAC3_AT_DECODER 1
%define CONFIG_GSM_MS_AT_DECODER 1
%define CONFIG_ILBC_AT_DECODER 1
%define CONFIG_MP1_AT_DECODER 1
%define CONFIG_MP2_AT_DECODER 1
%define CONFIG_MP3_AT_DECODER 1
%define CONFIG_PCM_ALAW_AT_DECODER 1
%define CONFIG_PCM_MULAW_AT_DECODER 1
%define CONFIG_QDMC_AT_DECODER 1
%define CONFIG_QDM2_AT_DECODER 1
%define CONFIG_LIBAOM_AV1_DECODER 0
%define CONFIG_LIBARIBB24_DECODER 0
%define CONFIG_LIBCELT_DECODER 0
%define CONFIG_LIBCODEC2_DECODER 0
%define CONFIG_LIBDAV1D_DECODER 0
%define CONFIG_LIBDAVS2_DECODER 0
%define CONFIG_LIBFDK_AAC_DECODER 0
%define CONFIG_LIBGSM_DECODER 0
%define CONFIG_LIBGSM_MS_DECODER 0
%define CONFIG_LIBILBC_DECODER 0
%define CONFIG_LIBOPENCORE_AMRNB_DECODER 0
%define CONFIG_LIBOPENCORE_AMRWB_DECODER 0
%define CONFIG_LIBOPENJPEG_DECODER 0
%define CONFIG_LIBOPUS_DECODER 0
%define CONFIG_LIBRSVG_DECODER 0
%define CONFIG_LIBSPEEX_DECODER 0
%define CONFIG_LIBVORBIS_DECODER 0
%define CONFIG_LIBVPX_VP8_DECODER 0
%define CONFIG_LIBVPX_VP9_DECODER 0
%define CONFIG_LIBZVBI_TELETEXT_DECODER 0
%define CONFIG_BINTEXT_DECODER 1
%define CONFIG_XBIN_DECODER 1
%define CONFIG_IDF_DECODER 1
%define CONFIG_LIBOPENH264_DECODER 0
%define CONFIG_H264_CUVID_DECODER 0
%define CONFIG_HEVC_CUVID_DECODER 0
%define CONFIG_HEVC_MEDIACODEC_DECODER 0
%define CONFIG_MJPEG_CUVID_DECODER 0
%define CONFIG_MPEG1_CUVID_DECODER 0
%define CONFIG_MPEG2_CUVID_DECODER 0
%define CONFIG_MPEG4_CUVID_DECODER 0
%define CONFIG_MPEG4_MEDIACODEC_DECODER 0
%define CONFIG_VC1_CUVID_DECODER 0
%define CONFIG_VP8_CUVID_DECODER 0
%define CONFIG_VP8_MEDIACODEC_DECODER 0
%define CONFIG_VP8_QSV_DECODER 0
%define CONFIG_VP9_CUVID_DECODER 0
%define CONFIG_VP9_MEDIACODEC_DECODER 0
%define CONFIG_A64MULTI_ENCODER 1
%define CONFIG_A64MULTI5_ENCODER 1
%define CONFIG_ALIAS_PIX_ENCODER 1
%define CONFIG_AMV_ENCODER 1
%define CONFIG_APNG_ENCODER 1
%define CONFIG_ASV1_ENCODER 1
%define CONFIG_ASV2_ENCODER 1
%define CONFIG_AVRP_ENCODER 1
%define CONFIG_AVUI_ENCODER 1
%define CONFIG_AYUV_ENCODER 1
%define CONFIG_BMP_ENCODER 1
%define CONFIG_CINEPAK_ENCODER 1
%define CONFIG_CLJR_ENCODER 1
%define CONFIG_COMFORTNOISE_ENCODER 1
%define CONFIG_DNXHD_ENCODER 1
%define CONFIG_DPX_ENCODER 1
%define CONFIG_DVVIDEO_ENCODER 1
%define CONFIG_FFV1_ENCODER 1
%define CONFIG_FFVHUFF_ENCODER 1
%define CONFIG_FITS_ENCODER 1
%define CONFIG_FLASHSV_ENCODER 1
%define CONFIG_FLASHSV2_ENCODER 1
%define CONFIG_FLV_ENCODER 1
%define CONFIG_GIF_ENCODER 1
%define CONFIG_H261_ENCODER 1
%define CONFIG_H263_ENCODER 1
%define CONFIG_H263P_ENCODER 1
%define CONFIG_HAP_ENCODER 0
%define CONFIG_HUFFYUV_ENCODER 1
%define CONFIG_JPEG2000_ENCODER 1
%define CONFIG_JPEGLS_ENCODER 1
%define CONFIG_LJPEG_ENCODER 1
%define CONFIG_MAGICYUV_ENCODER 1
%define CONFIG_MJPEG_ENCODER 1
%define CONFIG_MPEG1VIDEO_ENCODER 1
%define CONFIG_MPEG2VIDEO_ENCODER 1
%define CONFIG_MPEG4_ENCODER 1
%define CONFIG_MSMPEG4V2_ENCODER 1
%define CONFIG_MSMPEG4V3_ENCODER 1
%define CONFIG_MSVIDEO1_ENCODER 1
%define CONFIG_PAM_ENCODER 1
%define CONFIG_PBM_ENCODER 1
%define CONFIG_PCX_ENCODER 1
%define CONFIG_PGM_ENCODER 1
%define CONFIG_PGMYUV_ENCODER 1
%define CONFIG_PNG_ENCODER 1
%define CONFIG_PPM_ENCODER 1
%define CONFIG_PRORES_ENCODER 1
%define CONFIG_PRORES_AW_ENCODER 1
%define CONFIG_PRORES_KS_ENCODER 1
%define CONFIG_QTRLE_ENCODER 1
%define CONFIG_R10K_ENCODER 1
%define CONFIG_R210_ENCODER 1
%define CONFIG_RAWVIDEO_ENCODER 1
%define CONFIG_ROQ_ENCODER 1
%define CONFIG_RV10_ENCODER 1
%define CONFIG_RV20_ENCODER 1
%define CONFIG_S302M_ENCODER 1
%define CONFIG_SGI_ENCODER 1
%define CONFIG_SNOW_ENCODER 1
%define CONFIG_SUNRAST_ENCODER 1
%define CONFIG_SVQ1_ENCODER 1
%define CONFIG_TARGA_ENCODER 1
%define CONFIG_TIFF_ENCODER 1
%define CONFIG_UTVIDEO_ENCODER 1
%define CONFIG_V210_ENCODER 1
%define CONFIG_V308_ENCODER 1
%define CONFIG_V408_ENCODER 1
%define CONFIG_V410_ENCODER 1
%define CONFIG_VC2_ENCODER 1
%define CONFIG_WRAPPED_AVFRAME_ENCODER 1
%define CONFIG_WMV1_ENCODER 1
%define CONFIG_WMV2_ENCODER 1
%define CONFIG_XBM_ENCODER 1
%define CONFIG_XFACE_ENCODER 1
%define CONFIG_XWD_ENCODER 1
%define CONFIG_Y41P_ENCODER 1
%define CONFIG_YUV4_ENCODER 1
%define CONFIG_ZLIB_ENCODER 1
%define CONFIG_ZMBV_ENCODER 1
%define CONFIG_AAC_ENCODER 1
%define CONFIG_AC3_ENCODER 1
%define CONFIG_AC3_FIXED_ENCODER 1
%define CONFIG_ALAC_ENCODER 1
%define CONFIG_APTX_ENCODER 1
%define CONFIG_APTX_HD_ENCODER 1
%define CONFIG_DCA_ENCODER 1
%define CONFIG_EAC3_ENCODER 1
%define CONFIG_FLAC_ENCODER 1
%define CONFIG_G723_1_ENCODER 1
%define CONFIG_MLP_ENCODER 1
%define CONFIG_MP2_ENCODER 1
%define CONFIG_MP2FIXED_ENCODER 1
%define CONFIG_NELLYMOSER_ENCODER 1
%define CONFIG_OPUS_ENCODER 1
%define CONFIG_RA_144_ENCODER 1
%define CONFIG_SBC_ENCODER 1
%define CONFIG_SONIC_ENCODER 1
%define CONFIG_SONIC_LS_ENCODER 1
%define CONFIG_TRUEHD_ENCODER 1
%define CONFIG_TTA_ENCODER 1
%define CONFIG_VORBIS_ENCODER 1
%define CONFIG_WAVPACK_ENCODER 1
%define CONFIG_WMAV1_ENCODER 1
%define CONFIG_WMAV2_ENCODER 1
%define CONFIG_PCM_ALAW_ENCODER 1
%define CONFIG_PCM_DVD_ENCODER 1
%define CONFIG_PCM_F32BE_ENCODER 1
%define CONFIG_PCM_F32LE_ENCODER 1
%define CONFIG_PCM_F64BE_ENCODER 1
%define CONFIG_PCM_F64LE_ENCODER 1
%define CONFIG_PCM_MULAW_ENCODER 1
%define CONFIG_PCM_S8_ENCODER 1
%define CONFIG_PCM_S8_PLANAR_ENCODER 1
%define CONFIG_PCM_S16BE_ENCODER 1
%define CONFIG_PCM_S16BE_PLANAR_ENCODER 1
%define CONFIG_PCM_S16LE_ENCODER 1
%define CONFIG_PCM_S16LE_PLANAR_ENCODER 1
%define CONFIG_PCM_S24BE_ENCODER 1
%define CONFIG_PCM_S24DAUD_ENCODER 1
%define CONFIG_PCM_S24LE_ENCODER 1
%define CONFIG_PCM_S24LE_PLANAR_ENCODER 1
%define CONFIG_PCM_S32BE_ENCODER 1
%define CONFIG_PCM_S32LE_ENCODER 1
%define CONFIG_PCM_S32LE_PLANAR_ENCODER 1
%define CONFIG_PCM_S64BE_ENCODER 1
%define CONFIG_PCM_S64LE_ENCODER 1
%define CONFIG_PCM_U8_ENCODER 1
%define CONFIG_PCM_U16BE_ENCODER 1
%define CONFIG_PCM_U16LE_ENCODER 1
%define CONFIG_PCM_U24BE_ENCODER 1
%define CONFIG_PCM_U24LE_ENCODER 1
%define CONFIG_PCM_U32BE_ENCODER 1
%define CONFIG_PCM_U32LE_ENCODER 1
%define CONFIG_PCM_VIDC_ENCODER 1
%define CONFIG_ROQ_DPCM_ENCODER 1
%define CONFIG_ADPCM_ADX_ENCODER 1
%define CONFIG_ADPCM_G722_ENCODER 1
%define CONFIG_ADPCM_G726_ENCODER 1
%define CONFIG_ADPCM_G726LE_ENCODER 1
%define CONFIG_ADPCM_IMA_QT_ENCODER 1
%define CONFIG_ADPCM_IMA_WAV_ENCODER 1
%define CONFIG_ADPCM_MS_ENCODER 1
%define CONFIG_ADPCM_SWF_ENCODER 1
%define CONFIG_ADPCM_YAMAHA_ENCODER 1
%define CONFIG_SSA_ENCODER 1
%define CONFIG_ASS_ENCODER 1
%define CONFIG_DVBSUB_ENCODER 1
%define CONFIG_DVDSUB_ENCODER 1
%define CONFIG_MOVTEXT_ENCODER 1
%define CONFIG_SRT_ENCODER 1
%define CONFIG_SUBRIP_ENCODER 1
%define CONFIG_TEXT_ENCODER 1
%define CONFIG_WEBVTT_ENCODER 1
%define CONFIG_XSUB_ENCODER 1
%define CONFIG_AAC_AT_ENCODER 1
%define CONFIG_ALAC_AT_ENCODER 1
%define CONFIG_ILBC_AT_ENCODER 1
%define CONFIG_PCM_ALAW_AT_ENCODER 1
%define CONFIG_PCM_MULAW_AT_ENCODER 1
%define CONFIG_LIBAOM_AV1_ENCODER 0
%define CONFIG_LIBCODEC2_ENCODER 0
%define CONFIG_LIBFDK_AAC_ENCODER 0
%define CONFIG_LIBGSM_ENCODER 0
%define CONFIG_LIBGSM_MS_ENCODER 0
%define CONFIG_LIBILBC_ENCODER 0
%define CONFIG_LIBMP3LAME_ENCODER 0
%define CONFIG_LIBOPENCORE_AMRNB_ENCODER 0
%define CONFIG_LIBOPENJPEG_ENCODER 0
%define CONFIG_LIBOPUS_ENCODER 0
%define CONFIG_LIBSHINE_ENCODER 0
%define CONFIG_LIBSPEEX_ENCODER 0
%define CONFIG_LIBTHEORA_ENCODER 0
%define CONFIG_LIBTWOLAME_ENCODER 0
%define CONFIG_LIBVO_AMRWBENC_ENCODER 0
%define CONFIG_LIBVORBIS_ENCODER 0
%define CONFIG_LIBVPX_VP8_ENCODER 0
%define CONFIG_LIBVPX_VP9_ENCODER 0
%define CONFIG_LIBWAVPACK_ENCODER 0
%define CONFIG_LIBWEBP_ANIM_ENCODER 0
%define CONFIG_LIBWEBP_ENCODER 0
%define CONFIG_LIBX262_ENCODER 0
%define CONFIG_LIBX264_ENCODER 0
%define CONFIG_LIBX264RGB_ENCODER 0
%define CONFIG_LIBX265_ENCODER 0
%define CONFIG_LIBXAVS_ENCODER 0
%define CONFIG_LIBXAVS2_ENCODER 0
%define CONFIG_LIBXVID_ENCODER 0
%define CONFIG_H263_V4L2M2M_ENCODER 0
%define CONFIG_LIBOPENH264_ENCODER 0
%define CONFIG_H264_AMF_ENCODER 0
%define CONFIG_H264_NVENC_ENCODER 0
%define CONFIG_H264_OMX_ENCODER 0
%define CONFIG_H264_QSV_ENCODER 0
%define CONFIG_H264_V4L2M2M_ENCODER 0
%define CONFIG_H264_VAAPI_ENCODER 0
%define CONFIG_H264_VIDEOTOOLBOX_ENCODER 1
%define CONFIG_NVENC_ENCODER 0
%define CONFIG_NVENC_H264_ENCODER 0
%define CONFIG_NVENC_HEVC_ENCODER 0
%define CONFIG_HEVC_AMF_ENCODER 0
%define CONFIG_HEVC_NVENC_ENCODER 0
%define CONFIG_HEVC_QSV_ENCODER 0
%define CONFIG_HEVC_V4L2M2M_ENCODER 0
%define CONFIG_HEVC_VAAPI_ENCODER 0
%define CONFIG_HEVC_VIDEOTOOLBOX_ENCODER 1
%define CONFIG_LIBKVAZAAR_ENCODER 0
%define CONFIG_MJPEG_QSV_ENCODER 0
%define CONFIG_MJPEG_VAAPI_ENCODER 0
%define CONFIG_MPEG2_QSV_ENCODER 0
%define CONFIG_MPEG2_VAAPI_ENCODER 0
%define CONFIG_MPEG4_V4L2M2M_ENCODER 0
%define CONFIG_VP8_V4L2M2M_ENCODER 0
%define CONFIG_VP8_VAAPI_ENCODER 0
%define CONFIG_VP9_VAAPI_ENCODER 0
%define CONFIG_H263_VAAPI_HWACCEL 0
%define CONFIG_H263_VIDEOTOOLBOX_HWACCEL 1
%define CONFIG_H264_D3D11VA_HWACCEL 0
%define CONFIG_H264_D3D11VA2_HWACCEL 0
%define CONFIG_H264_DXVA2_HWACCEL 0
%define CONFIG_H264_NVDEC_HWACCEL 0
%define CONFIG_H264_VAAPI_HWACCEL 0
%define CONFIG_H264_VDPAU_HWACCEL 0
%define CONFIG_H264_VIDEOTOOLBOX_HWACCEL 1
%define CONFIG_HEVC_D3D11VA_HWACCEL 0
%define CONFIG_HEVC_D3D11VA2_HWACCEL 0
%define CONFIG_HEVC_DXVA2_HWACCEL 0
%define CONFIG_HEVC_NVDEC_HWACCEL 0
%define CONFIG_HEVC_VAAPI_HWACCEL 0
%define CONFIG_HEVC_VDPAU_HWACCEL 0
%define CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 1
%define CONFIG_MJPEG_NVDEC_HWACCEL 0
%define CONFIG_MJPEG_VAAPI_HWACCEL 0
%define CONFIG_MPEG1_NVDEC_HWACCEL 0
%define CONFIG_MPEG1_VDPAU_HWACCEL 0
%define CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL 1
%define CONFIG_MPEG1_XVMC_HWACCEL 0
%define CONFIG_MPEG2_D3D11VA_HWACCEL 0
%define CONFIG_MPEG2_D3D11VA2_HWACCEL 0
%define CONFIG_MPEG2_NVDEC_HWACCEL 0
%define CONFIG_MPEG2_DXVA2_HWACCEL 0
%define CONFIG_MPEG2_VAAPI_HWACCEL 0
%define CONFIG_MPEG2_VDPAU_HWACCEL 0
%define CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL 1
%define CONFIG_MPEG2_XVMC_HWACCEL 0
%define CONFIG_MPEG4_NVDEC_HWACCEL 0
%define CONFIG_MPEG4_VAAPI_HWACCEL 0
%define CONFIG_MPEG4_VDPAU_HWACCEL 0
%define CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL 1
%define CONFIG_VC1_D3D11VA_HWACCEL 0
%define CONFIG_VC1_D3D11VA2_HWACCEL 0
%define CONFIG_VC1_DXVA2_HWACCEL 0
%define CONFIG_VC1_NVDEC_HWACCEL 0
%define CONFIG_VC1_VAAPI_HWACCEL 0
%define CONFIG_VC1_VDPAU_HWACCEL 0
%define CONFIG_VP8_NVDEC_HWACCEL 0
%define CONFIG_VP8_VAAPI_HWACCEL 0
%define CONFIG_VP9_D3D11VA_HWACCEL 0
%define CONFIG_VP9_D3D11VA2_HWACCEL 0
%define CONFIG_VP9_DXVA2_HWACCEL 0
%define CONFIG_VP9_NVDEC_HWACCEL 0
%define CONFIG_VP9_VAAPI_HWACCEL 0
%define CONFIG_WMV3_D3D11VA_HWACCEL 0
%define CONFIG_WMV3_D3D11VA2_HWACCEL 0
%define CONFIG_WMV3_DXVA2_HWACCEL 0
%define CONFIG_WMV3_NVDEC_HWACCEL 0
%define CONFIG_WMV3_VAAPI_HWACCEL 0
%define CONFIG_WMV3_VDPAU_HWACCEL 0
%define CONFIG_AAC_PARSER 1
%define CONFIG_AAC_LATM_PARSER 1
%define CONFIG_AC3_PARSER 1
%define CONFIG_ADX_PARSER 1
%define CONFIG_AV1_PARSER 1
%define CONFIG_AVS2_PARSER 1
%define CONFIG_BMP_PARSER 1
%define CONFIG_CAVSVIDEO_PARSER 1
%define CONFIG_COOK_PARSER 1
%define CONFIG_DCA_PARSER 1
%define CONFIG_DIRAC_PARSER 1
%define CONFIG_DNXHD_PARSER 1
%define CONFIG_DPX_PARSER 1
%define CONFIG_DVAUDIO_PARSER 1
%define CONFIG_DVBSUB_PARSER 1
%define CONFIG_DVDSUB_PARSER 1
%define CONFIG_DVD_NAV_PARSER 1
%define CONFIG_FLAC_PARSER 1
%define CONFIG_G723_1_PARSER 1
%define CONFIG_G729_PARSER 1
%define CONFIG_GIF_PARSER 1
%define CONFIG_GSM_PARSER 1
%define CONFIG_H261_PARSER 1
%define CONFIG_H263_PARSER 1
%define CONFIG_H264_PARSER 1
%define CONFIG_HEVC_PARSER 1
%define CONFIG_MJPEG_PARSER 1
%define CONFIG_MLP_PARSER 1
%define CONFIG_MPEG4VIDEO_PARSER 1
%define CONFIG_MPEGAUDIO_PARSER 1
%define CONFIG_MPEGVIDEO_PARSER 1
%define CONFIG_OPUS_PARSER 1
%define CONFIG_PNG_PARSER 1
%define CONFIG_PNM_PARSER 1
%define CONFIG_RV30_PARSER 1
%define CONFIG_RV40_PARSER 1
%define CONFIG_SBC_PARSER 1
%define CONFIG_SIPR_PARSER 1
%define CONFIG_TAK_PARSER 1
%define CONFIG_VC1_PARSER 1
%define CONFIG_VORBIS_PARSER 1
%define CONFIG_VP3_PARSER 1
%define CONFIG_VP8_PARSER 1
%define CONFIG_VP9_PARSER 1
%define CONFIG_XMA_PARSER 1
%define CONFIG_ALSA_INDEV 0
%define CONFIG_ANDROID_CAMERA_INDEV 0
%define CONFIG_AVFOUNDATION_INDEV 1
%define CONFIG_BKTR_INDEV 0
%define CONFIG_DECKLINK_INDEV 0
%define CONFIG_DSHOW_INDEV 0
%define CONFIG_FBDEV_INDEV 0
%define CONFIG_GDIGRAB_INDEV 0
%define CONFIG_IEC61883_INDEV 0
%define CONFIG_JACK_INDEV 0
%define CONFIG_KMSGRAB_INDEV 0
%define CONFIG_LAVFI_INDEV 1
%define CONFIG_OPENAL_INDEV 0
%define CONFIG_OSS_INDEV 0
%define CONFIG_PULSE_INDEV 0
%define CONFIG_SNDIO_INDEV 0
%define CONFIG_V4L2_INDEV 0
%define CONFIG_VFWCAP_INDEV 0
%define CONFIG_XCBGRAB_INDEV 0
%define CONFIG_LIBCDIO_INDEV 0
%define CONFIG_LIBDC1394_INDEV 0
%define CONFIG_ALSA_OUTDEV 0
%define CONFIG_CACA_OUTDEV 0
%define CONFIG_DECKLINK_OUTDEV 0
%define CONFIG_FBDEV_OUTDEV 0
%define CONFIG_OPENGL_OUTDEV 0
%define CONFIG_OSS_OUTDEV 0
%define CONFIG_PULSE_OUTDEV 0
%define CONFIG_SDL2_OUTDEV 0
%define CONFIG_SNDIO_OUTDEV 0
%define CONFIG_V4L2_OUTDEV 0
%define CONFIG_XV_OUTDEV 0
%define CONFIG_ABENCH_FILTER 1
%define CONFIG_ACOMPRESSOR_FILTER 1
%define CONFIG_ACONTRAST_FILTER 1
%define CONFIG_ACOPY_FILTER 1
%define CONFIG_ACUE_FILTER 1
%define CONFIG_ACROSSFADE_FILTER 1
%define CONFIG_ACROSSOVER_FILTER 1
%define CONFIG_ACRUSHER_FILTER 1
%define CONFIG_ADECLICK_FILTER 1
%define CONFIG_ADECLIP_FILTER 1
%define CONFIG_ADELAY_FILTER 1
%define CONFIG_ADERIVATIVE_FILTER 1
%define CONFIG_AECHO_FILTER 1
%define CONFIG_AEMPHASIS_FILTER 1
%define CONFIG_AEVAL_FILTER 1
%define CONFIG_AFADE_FILTER 1
%define CONFIG_AFFTDN_FILTER 1
%define CONFIG_AFFTFILT_FILTER 1
%define CONFIG_AFIR_FILTER 1
%define CONFIG_AFORMAT_FILTER 1
%define CONFIG_AGATE_FILTER 1
%define CONFIG_AIIR_FILTER 1
%define CONFIG_AINTEGRAL_FILTER 1
%define CONFIG_AINTERLEAVE_FILTER 1
%define CONFIG_ALIMITER_FILTER 1
%define CONFIG_ALLPASS_FILTER 1
%define CONFIG_ALOOP_FILTER 1
%define CONFIG_AMERGE_FILTER 1
%define CONFIG_AMETADATA_FILTER 1
%define CONFIG_AMIX_FILTER 1
%define CONFIG_AMULTIPLY_FILTER 1
%define CONFIG_ANEQUALIZER_FILTER 1
%define CONFIG_ANLMDN_FILTER 1
%define CONFIG_ANULL_FILTER 1
%define CONFIG_APAD_FILTER 1
%define CONFIG_APERMS_FILTER 1
%define CONFIG_APHASER_FILTER 1
%define CONFIG_APULSATOR_FILTER 1
%define CONFIG_AREALTIME_FILTER 1
%define CONFIG_ARESAMPLE_FILTER 1
%define CONFIG_AREVERSE_FILTER 1
%define CONFIG_ASELECT_FILTER 1
%define CONFIG_ASENDCMD_FILTER 1
%define CONFIG_ASETNSAMPLES_FILTER 1
%define CONFIG_ASETPTS_FILTER 1
%define CONFIG_ASETRATE_FILTER 1
%define CONFIG_ASETTB_FILTER 1
%define CONFIG_ASHOWINFO_FILTER 1
%define CONFIG_ASIDEDATA_FILTER 1
%define CONFIG_ASOFTCLIP_FILTER 1
%define CONFIG_ASPLIT_FILTER 1
%define CONFIG_ASR_FILTER 0
%define CONFIG_ASTATS_FILTER 1
%define CONFIG_ASTREAMSELECT_FILTER 1
%define CONFIG_ATEMPO_FILTER 1
%define CONFIG_ATRIM_FILTER 1
%define CONFIG_AZMQ_FILTER 0
%define CONFIG_BANDPASS_FILTER 1
%define CONFIG_BANDREJECT_FILTER 1
%define CONFIG_BASS_FILTER 1
%define CONFIG_BIQUAD_FILTER 1
%define CONFIG_BS2B_FILTER 0
%define CONFIG_CHANNELMAP_FILTER 1
%define CONFIG_CHANNELSPLIT_FILTER 1
%define CONFIG_CHORUS_FILTER 1
%define CONFIG_COMPAND_FILTER 1
%define CONFIG_COMPENSATIONDELAY_FILTER 1
%define CONFIG_CROSSFEED_FILTER 1
%define CONFIG_CRYSTALIZER_FILTER 1
%define CONFIG_DCSHIFT_FILTER 1
%define CONFIG_DEESSER_FILTER 1
%define CONFIG_DRMETER_FILTER 1
%define CONFIG_DYNAUDNORM_FILTER 1
%define CONFIG_EARWAX_FILTER 1
%define CONFIG_EBUR128_FILTER 1
%define CONFIG_EQUALIZER_FILTER 1
%define CONFIG_EXTRASTEREO_FILTER 1
%define CONFIG_FIREQUALIZER_FILTER 1
%define CONFIG_FLANGER_FILTER 1
%define CONFIG_HAAS_FILTER 1
%define CONFIG_HDCD_FILTER 1
%define CONFIG_HEADPHONE_FILTER 1
%define CONFIG_HIGHPASS_FILTER 1
%define CONFIG_HIGHSHELF_FILTER 1
%define CONFIG_JOIN_FILTER 1
%define CONFIG_LADSPA_FILTER 0
%define CONFIG_LOUDNORM_FILTER 1
%define CONFIG_LOWPASS_FILTER 1
%define CONFIG_LOWSHELF_FILTER 1
%define CONFIG_LV2_FILTER 0
%define CONFIG_MCOMPAND_FILTER 1
%define CONFIG_PAN_FILTER 1
%define CONFIG_REPLAYGAIN_FILTER 1
%define CONFIG_RESAMPLE_FILTER 0
%define CONFIG_RUBBERBAND_FILTER 0
%define CONFIG_SIDECHAINCOMPRESS_FILTER 1
%define CONFIG_SIDECHAINGATE_FILTER 1
%define CONFIG_SILENCEDETECT_FILTER 1
%define CONFIG_SILENCEREMOVE_FILTER 1
%define CONFIG_SOFALIZER_FILTER 0
%define CONFIG_STEREOTOOLS_FILTER 1
%define CONFIG_STEREOWIDEN_FILTER 1
%define CONFIG_SUPEREQUALIZER_FILTER 1
%define CONFIG_SURROUND_FILTER 1
%define CONFIG_TREBLE_FILTER 1
%define CONFIG_TREMOLO_FILTER 1
%define CONFIG_VIBRATO_FILTER 1
%define CONFIG_VOLUME_FILTER 1
%define CONFIG_VOLUMEDETECT_FILTER 1
%define CONFIG_AEVALSRC_FILTER 1
%define CONFIG_ANOISESRC_FILTER 1
%define CONFIG_ANULLSRC_FILTER 1
%define CONFIG_FLITE_FILTER 0
%define CONFIG_HILBERT_FILTER 1
%define CONFIG_SINC_FILTER 1
%define CONFIG_SINE_FILTER 1
%define CONFIG_ANULLSINK_FILTER 1
%define CONFIG_ALPHAEXTRACT_FILTER 1
%define CONFIG_ALPHAMERGE_FILTER 1
%define CONFIG_AMPLIFY_FILTER 1
%define CONFIG_ASS_FILTER 0
%define CONFIG_ATADENOISE_FILTER 1
%define CONFIG_AVGBLUR_FILTER 1
%define CONFIG_AVGBLUR_OPENCL_FILTER 0
%define CONFIG_BBOX_FILTER 1
%define CONFIG_BENCH_FILTER 1
%define CONFIG_BITPLANENOISE_FILTER 1
%define CONFIG_BLACKDETECT_FILTER 1
%define CONFIG_BLACKFRAME_FILTER 0
%define CONFIG_BLEND_FILTER 1
%define CONFIG_BM3D_FILTER 1
%define CONFIG_BOXBLUR_FILTER 0
%define CONFIG_BOXBLUR_OPENCL_FILTER 0
%define CONFIG_BWDIF_FILTER 1
%define CONFIG_CHROMAHOLD_FILTER 1
%define CONFIG_CHROMAKEY_FILTER 1
%define CONFIG_CHROMASHIFT_FILTER 1
%define CONFIG_CIESCOPE_FILTER 1
%define CONFIG_CODECVIEW_FILTER 1
%define CONFIG_COLORBALANCE_FILTER 1
%define CONFIG_COLORCHANNELMIXER_FILTER 1
%define CONFIG_COLORKEY_FILTER 1
%define CONFIG_COLORKEY_OPENCL_FILTER 0
%define CONFIG_COLORHOLD_FILTER 1
%define CONFIG_COLORLEVELS_FILTER 1
%define CONFIG_COLORMATRIX_FILTER 0
%define CONFIG_COLORSPACE_FILTER 1
%define CONFIG_CONVOLUTION_FILTER 1
%define CONFIG_CONVOLUTION_OPENCL_FILTER 0
%define CONFIG_CONVOLVE_FILTER 1
%define CONFIG_COPY_FILTER 1
%define CONFIG_COREIMAGE_FILTER 1
%define CONFIG_COVER_RECT_FILTER 0
%define CONFIG_CROP_FILTER 1
%define CONFIG_CROPDETECT_FILTER 0
%define CONFIG_CUE_FILTER 1
%define CONFIG_CURVES_FILTER 1
%define CONFIG_DATASCOPE_FILTER 1
%define CONFIG_DCTDNOIZ_FILTER 1
%define CONFIG_DEBAND_FILTER 1
%define CONFIG_DEBLOCK_FILTER 1
%define CONFIG_DECIMATE_FILTER 1
%define CONFIG_DECONVOLVE_FILTER 1
%define CONFIG_DEDOT_FILTER 1
%define CONFIG_DEFLATE_FILTER 1
%define CONFIG_DEFLICKER_FILTER 1
%define CONFIG_DEINTERLACE_QSV_FILTER 0
%define CONFIG_DEINTERLACE_VAAPI_FILTER 0
%define CONFIG_DEJUDDER_FILTER 1
%define CONFIG_DELOGO_FILTER 0
%define CONFIG_DENOISE_VAAPI_FILTER 0
%define CONFIG_DERAIN_FILTER 1
%define CONFIG_DESHAKE_FILTER 1
%define CONFIG_DESPILL_FILTER 1
%define CONFIG_DETELECINE_FILTER 1
%define CONFIG_DILATION_FILTER 1
%define CONFIG_DILATION_OPENCL_FILTER 0
%define CONFIG_DISPLACE_FILTER 1
%define CONFIG_DOUBLEWEAVE_FILTER 1
%define CONFIG_DRAWBOX_FILTER 1
%define CONFIG_DRAWGRAPH_FILTER 1
%define CONFIG_DRAWGRID_FILTER 1
%define CONFIG_DRAWTEXT_FILTER 0
%define CONFIG_EDGEDETECT_FILTER 1
%define CONFIG_ELBG_FILTER 1
%define CONFIG_ENTROPY_FILTER 1
%define CONFIG_EQ_FILTER 0
%define CONFIG_EROSION_FILTER 1
%define CONFIG_EROSION_OPENCL_FILTER 0
%define CONFIG_EXTRACTPLANES_FILTER 1
%define CONFIG_FADE_FILTER 1
%define CONFIG_FFTDNOIZ_FILTER 1
%define CONFIG_FFTFILT_FILTER 1
%define CONFIG_FIELD_FILTER 1
%define CONFIG_FIELDHINT_FILTER 1
%define CONFIG_FIELDMATCH_FILTER 1
%define CONFIG_FIELDORDER_FILTER 1
%define CONFIG_FILLBORDERS_FILTER 1
%define CONFIG_FIND_RECT_FILTER 0
%define CONFIG_FLOODFILL_FILTER 1
%define CONFIG_FORMAT_FILTER 1
%define CONFIG_FPS_FILTER 1
%define CONFIG_FRAMEPACK_FILTER 1
%define CONFIG_FRAMERATE_FILTER 1
%define CONFIG_FRAMESTEP_FILTER 1
%define CONFIG_FREEZEDETECT_FILTER 1
%define CONFIG_FREI0R_FILTER 0
%define CONFIG_FSPP_FILTER 0
%define CONFIG_GBLUR_FILTER 1
%define CONFIG_GEQ_FILTER 0
%define CONFIG_GRADFUN_FILTER 1
%define CONFIG_GRAPHMONITOR_FILTER 1
%define CONFIG_GREYEDGE_FILTER 1
%define CONFIG_HALDCLUT_FILTER 1
%define CONFIG_HFLIP_FILTER 1
%define CONFIG_HISTEQ_FILTER 0
%define CONFIG_HISTOGRAM_FILTER 1
%define CONFIG_HQDN3D_FILTER 0
%define CONFIG_HQX_FILTER 1
%define CONFIG_HSTACK_FILTER 1
%define CONFIG_HUE_FILTER 1
%define CONFIG_HWDOWNLOAD_FILTER 1
%define CONFIG_HWMAP_FILTER 1
%define CONFIG_HWUPLOAD_FILTER 1
%define CONFIG_HWUPLOAD_CUDA_FILTER 0
%define CONFIG_HYSTERESIS_FILTER 1
%define CONFIG_IDET_FILTER 1
%define CONFIG_IL_FILTER 1
%define CONFIG_INFLATE_FILTER 1
%define CONFIG_INTERLACE_FILTER 0
%define CONFIG_INTERLEAVE_FILTER 1
%define CONFIG_KERNDEINT_FILTER 0
%define CONFIG_LAGFUN_FILTER 1
%define CONFIG_LENSCORRECTION_FILTER 1
%define CONFIG_LENSFUN_FILTER 0
%define CONFIG_LIBVMAF_FILTER 0
%define CONFIG_LIMITER_FILTER 1
%define CONFIG_LOOP_FILTER 1
%define CONFIG_LUMAKEY_FILTER 1
%define CONFIG_LUT_FILTER 1
%define CONFIG_LUT1D_FILTER 1
%define CONFIG_LUT2_FILTER 1
%define CONFIG_LUT3D_FILTER 1
%define CONFIG_LUTRGB_FILTER 1
%define CONFIG_LUTYUV_FILTER 1
%define CONFIG_MASKEDCLAMP_FILTER 1
%define CONFIG_MASKEDMERGE_FILTER 1
%define CONFIG_MASKFUN_FILTER 1
%define CONFIG_MCDEINT_FILTER 0
%define CONFIG_MERGEPLANES_FILTER 1
%define CONFIG_MESTIMATE_FILTER 1
%define CONFIG_METADATA_FILTER 1
%define CONFIG_MIDEQUALIZER_FILTER 1
%define CONFIG_MINTERPOLATE_FILTER 1
%define CONFIG_MIX_FILTER 1
%define CONFIG_MPDECIMATE_FILTER 0
%define CONFIG_NEGATE_FILTER 1
%define CONFIG_NLMEANS_FILTER 1
%define CONFIG_NLMEANS_OPENCL_FILTER 0
%define CONFIG_NNEDI_FILTER 0
%define CONFIG_NOFORMAT_FILTER 1
%define CONFIG_NOISE_FILTER 1
%define CONFIG_NORMALIZE_FILTER 1
%define CONFIG_NULL_FILTER 1
%define CONFIG_OCR_FILTER 0
%define CONFIG_OCV_FILTER 0
%define CONFIG_OSCILLOSCOPE_FILTER 1
%define CONFIG_OVERLAY_FILTER 1
%define CONFIG_OVERLAY_OPENCL_FILTER 0
%define CONFIG_OVERLAY_QSV_FILTER 0
%define CONFIG_OWDENOISE_FILTER 0
%define CONFIG_PAD_FILTER 1
%define CONFIG_PALETTEGEN_FILTER 1
%define CONFIG_PALETTEUSE_FILTER 1
%define CONFIG_PERMS_FILTER 1
%define CONFIG_PERSPECTIVE_FILTER 0
%define CONFIG_PHASE_FILTER 0
%define CONFIG_PIXDESCTEST_FILTER 1
%define CONFIG_PIXSCOPE_FILTER 1
%define CONFIG_PP_FILTER 0
%define CONFIG_PP7_FILTER 0
%define CONFIG_PREMULTIPLY_FILTER 1
%define CONFIG_PREWITT_FILTER 1
%define CONFIG_PREWITT_OPENCL_FILTER 0
%define CONFIG_PROCAMP_VAAPI_FILTER 0
%define CONFIG_PROGRAM_OPENCL_FILTER 0
%define CONFIG_PSEUDOCOLOR_FILTER 1
%define CONFIG_PSNR_FILTER 1
%define CONFIG_PULLUP_FILTER 0
%define CONFIG_QP_FILTER 1
%define CONFIG_RANDOM_FILTER 1
%define CONFIG_READEIA608_FILTER 1
%define CONFIG_READVITC_FILTER 1
%define CONFIG_REALTIME_FILTER 1
%define CONFIG_REMAP_FILTER 1
%define CONFIG_REMOVEGRAIN_FILTER 1
%define CONFIG_REMOVELOGO_FILTER 1
%define CONFIG_REPEATFIELDS_FILTER 0
%define CONFIG_REVERSE_FILTER 1
%define CONFIG_RGBASHIFT_FILTER 1
%define CONFIG_ROBERTS_FILTER 1
%define CONFIG_ROBERTS_OPENCL_FILTER 0
%define CONFIG_ROTATE_FILTER 1
%define CONFIG_SAB_FILTER 0
%define CONFIG_SCALE_FILTER 1
%define CONFIG_SCALE_CUDA_FILTER 0
%define CONFIG_SCALE_NPP_FILTER 0
%define CONFIG_SCALE_QSV_FILTER 0
%define CONFIG_SCALE_VAAPI_FILTER 0
%define CONFIG_SCALE2REF_FILTER 1
%define CONFIG_SELECT_FILTER 1
%define CONFIG_SELECTIVECOLOR_FILTER 1
%define CONFIG_SENDCMD_FILTER 1
%define CONFIG_SEPARATEFIELDS_FILTER 1
%define CONFIG_SETDAR_FILTER 1
%define CONFIG_SETFIELD_FILTER 1
%define CONFIG_SETPARAMS_FILTER 1
%define CONFIG_SETPTS_FILTER 1
%define CONFIG_SETRANGE_FILTER 1
%define CONFIG_SETSAR_FILTER 1
%define CONFIG_SETTB_FILTER 1
%define CONFIG_SHARPNESS_VAAPI_FILTER 0
%define CONFIG_SHOWINFO_FILTER 1
%define CONFIG_SHOWPALETTE_FILTER 1
%define CONFIG_SHUFFLEFRAMES_FILTER 1
%define CONFIG_SHUFFLEPLANES_FILTER 1
%define CONFIG_SIDEDATA_FILTER 1
%define CONFIG_SIGNALSTATS_FILTER 1
%define CONFIG_SIGNATURE_FILTER 0
%define CONFIG_SMARTBLUR_FILTER 0
%define CONFIG_SOBEL_FILTER 1
%define CONFIG_SOBEL_OPENCL_FILTER 0
%define CONFIG_SPLIT_FILTER 1
%define CONFIG_SPP_FILTER 0
%define CONFIG_SR_FILTER 1
%define CONFIG_SSIM_FILTER 1
%define CONFIG_STEREO3D_FILTER 0
%define CONFIG_STREAMSELECT_FILTER 1
%define CONFIG_SUBTITLES_FILTER 0
%define CONFIG_SUPER2XSAI_FILTER 0
%define CONFIG_SWAPRECT_FILTER 1
%define CONFIG_SWAPUV_FILTER 1
%define CONFIG_TBLEND_FILTER 1
%define CONFIG_TELECINE_FILTER 1
%define CONFIG_THRESHOLD_FILTER 1
%define CONFIG_THUMBNAIL_FILTER 1
%define CONFIG_THUMBNAIL_CUDA_FILTER 0
%define CONFIG_TILE_FILTER 1
%define CONFIG_TINTERLACE_FILTER 0
%define CONFIG_TLUT2_FILTER 1
%define CONFIG_TMIX_FILTER 1
%define CONFIG_TONEMAP_FILTER 1
%define CONFIG_TONEMAP_OPENCL_FILTER 0
%define CONFIG_TPAD_FILTER 1
%define CONFIG_TRANSPOSE_FILTER 1
%define CONFIG_TRANSPOSE_NPP_FILTER 0
%define CONFIG_TRANSPOSE_OPENCL_FILTER 0
%define CONFIG_TRANSPOSE_VAAPI_FILTER 0
%define CONFIG_TRIM_FILTER 1
%define CONFIG_UNPREMULTIPLY_FILTER 1
%define CONFIG_UNSHARP_FILTER 1
%define CONFIG_UNSHARP_OPENCL_FILTER 0
%define CONFIG_USPP_FILTER 0
%define CONFIG_VAGUEDENOISER_FILTER 0
%define CONFIG_VECTORSCOPE_FILTER 1
%define CONFIG_VFLIP_FILTER 1
%define CONFIG_VFRDET_FILTER 1
%define CONFIG_VIBRANCE_FILTER 1
%define CONFIG_VIDSTABDETECT_FILTER 0
%define CONFIG_VIDSTABTRANSFORM_FILTER 0
%define CONFIG_VIGNETTE_FILTER 1
%define CONFIG_VMAFMOTION_FILTER 1
%define CONFIG_VPP_QSV_FILTER 0
%define CONFIG_VSTACK_FILTER 1
%define CONFIG_W3FDIF_FILTER 1
%define CONFIG_WAVEFORM_FILTER 1
%define CONFIG_WEAVE_FILTER 1
%define CONFIG_XBR_FILTER 1
%define CONFIG_XMEDIAN_FILTER 1
%define CONFIG_XSTACK_FILTER 1
%define CONFIG_YADIF_FILTER 1
%define CONFIG_YADIF_CUDA_FILTER 0
%define CONFIG_ZMQ_FILTER 0
%define CONFIG_ZOOMPAN_FILTER 1
%define CONFIG_ZSCALE_FILTER 0
%define CONFIG_ALLRGB_FILTER 1
%define CONFIG_ALLYUV_FILTER 1
%define CONFIG_CELLAUTO_FILTER 1
%define CONFIG_COLOR_FILTER 1
%define CONFIG_COREIMAGESRC_FILTER 1
%define CONFIG_FREI0R_SRC_FILTER 0
%define CONFIG_HALDCLUTSRC_FILTER 1
%define CONFIG_LIFE_FILTER 1
%define CONFIG_MANDELBROT_FILTER 1
%define CONFIG_MPTESTSRC_FILTER 0
%define CONFIG_NULLSRC_FILTER 1
%define CONFIG_OPENCLSRC_FILTER 0
%define CONFIG_PAL75BARS_FILTER 1
%define CONFIG_PAL100BARS_FILTER 1
%define CONFIG_RGBTESTSRC_FILTER 1
%define CONFIG_SMPTEBARS_FILTER 1
%define CONFIG_SMPTEHDBARS_FILTER 1
%define CONFIG_TESTSRC_FILTER 1
%define CONFIG_TESTSRC2_FILTER 1
%define CONFIG_YUVTESTSRC_FILTER 1
%define CONFIG_NULLSINK_FILTER 1
%define CONFIG_ABITSCOPE_FILTER 1
%define CONFIG_ADRAWGRAPH_FILTER 1
%define CONFIG_AGRAPHMONITOR_FILTER 1
%define CONFIG_AHISTOGRAM_FILTER 1
%define CONFIG_APHASEMETER_FILTER 1
%define CONFIG_AVECTORSCOPE_FILTER 1
%define CONFIG_CONCAT_FILTER 1
%define CONFIG_SHOWCQT_FILTER 1
%define CONFIG_SHOWFREQS_FILTER 1
%define CONFIG_SHOWSPATIAL_FILTER 1
%define CONFIG_SHOWSPECTRUM_FILTER 1
%define CONFIG_SHOWSPECTRUMPIC_FILTER 1
%define CONFIG_SHOWVOLUME_FILTER 1
%define CONFIG_SHOWWAVES_FILTER 1
%define CONFIG_SHOWWAVESPIC_FILTER 1
%define CONFIG_SPECTRUMSYNTH_FILTER 1
%define CONFIG_AMOVIE_FILTER 1
%define CONFIG_MOVIE_FILTER 1
%define CONFIG_AFIFO_FILTER 1
%define CONFIG_FIFO_FILTER 1
%define CONFIG_AA_DEMUXER 1
%define CONFIG_AAC_DEMUXER 1
%define CONFIG_AC3_DEMUXER 1
%define CONFIG_ACM_DEMUXER 1
%define CONFIG_ACT_DEMUXER 1
%define CONFIG_ADF_DEMUXER 1
%define CONFIG_ADP_DEMUXER 1
%define CONFIG_ADS_DEMUXER 1
%define CONFIG_ADX_DEMUXER 1
%define CONFIG_AEA_DEMUXER 1
%define CONFIG_AFC_DEMUXER 1
%define CONFIG_AIFF_DEMUXER 1
%define CONFIG_AIX_DEMUXER 1
%define CONFIG_AMR_DEMUXER 1
%define CONFIG_AMRNB_DEMUXER 1
%define CONFIG_AMRWB_DEMUXER 1
%define CONFIG_ANM_DEMUXER 1
%define CONFIG_APC_DEMUXER 1
%define CONFIG_APE_DEMUXER 1
%define CONFIG_APNG_DEMUXER 1
%define CONFIG_APTX_DEMUXER 1
%define CONFIG_APTX_HD_DEMUXER 1
%define CONFIG_AQTITLE_DEMUXER 1
%define CONFIG_ASF_DEMUXER 1
%define CONFIG_ASF_O_DEMUXER 1
%define CONFIG_ASS_DEMUXER 1
%define CONFIG_AST_DEMUXER 1
%define CONFIG_AU_DEMUXER 1
%define CONFIG_AVI_DEMUXER 1
%define CONFIG_AVISYNTH_DEMUXER 0
%define CONFIG_AVR_DEMUXER 1
%define CONFIG_AVS_DEMUXER 1
%define CONFIG_AVS2_DEMUXER 1
%define CONFIG_BETHSOFTVID_DEMUXER 1
%define CONFIG_BFI_DEMUXER 1
%define CONFIG_BINTEXT_DEMUXER 1
%define CONFIG_BINK_DEMUXER 1
%define CONFIG_BIT_DEMUXER 1
%define CONFIG_BMV_DEMUXER 1
%define CONFIG_BFSTM_DEMUXER 1
%define CONFIG_BRSTM_DEMUXER 1
%define CONFIG_BOA_DEMUXER 1
%define CONFIG_C93_DEMUXER 1
%define CONFIG_CAF_DEMUXER 1
%define CONFIG_CAVSVIDEO_DEMUXER 1
%define CONFIG_CDG_DEMUXER 1
%define CONFIG_CDXL_DEMUXER 1
%define CONFIG_CINE_DEMUXER 1
%define CONFIG_CODEC2_DEMUXER 1
%define CONFIG_CODEC2RAW_DEMUXER 1
%define CONFIG_CONCAT_DEMUXER 1
%define CONFIG_DASH_DEMUXER 0
%define CONFIG_DATA_DEMUXER 1
%define CONFIG_DAUD_DEMUXER 1
%define CONFIG_DCSTR_DEMUXER 1
%define CONFIG_DFA_DEMUXER 1
%define CONFIG_DHAV_DEMUXER 1
%define CONFIG_DIRAC_DEMUXER 1
%define CONFIG_DNXHD_DEMUXER 1
%define CONFIG_DSF_DEMUXER 1
%define CONFIG_DSICIN_DEMUXER 1
%define CONFIG_DSS_DEMUXER 1
%define CONFIG_DTS_DEMUXER 1
%define CONFIG_DTSHD_DEMUXER 1
%define CONFIG_DV_DEMUXER 1
%define CONFIG_DVBSUB_DEMUXER 1
%define CONFIG_DVBTXT_DEMUXER 1
%define CONFIG_DXA_DEMUXER 1
%define CONFIG_EA_DEMUXER 1
%define CONFIG_EA_CDATA_DEMUXER 1
%define CONFIG_EAC3_DEMUXER 1
%define CONFIG_EPAF_DEMUXER 1
%define CONFIG_FFMETADATA_DEMUXER 1
%define CONFIG_FILMSTRIP_DEMUXER 1
%define CONFIG_FITS_DEMUXER 1
%define CONFIG_FLAC_DEMUXER 1
%define CONFIG_FLIC_DEMUXER 1
%define CONFIG_FLV_DEMUXER 1
%define CONFIG_LIVE_FLV_DEMUXER 1
%define CONFIG_FOURXM_DEMUXER 1
%define CONFIG_FRM_DEMUXER 1
%define CONFIG_FSB_DEMUXER 1
%define CONFIG_G722_DEMUXER 1
%define CONFIG_G723_1_DEMUXER 1
%define CONFIG_G726_DEMUXER 1
%define CONFIG_G726LE_DEMUXER 1
%define CONFIG_G729_DEMUXER 1
%define CONFIG_GDV_DEMUXER 1
%define CONFIG_GENH_DEMUXER 1
%define CONFIG_GIF_DEMUXER 1
%define CONFIG_GSM_DEMUXER 1
%define CONFIG_GXF_DEMUXER 1
%define CONFIG_H261_DEMUXER 1
%define CONFIG_H263_DEMUXER 1
%define CONFIG_H264_DEMUXER 1
%define CONFIG_HCOM_DEMUXER 1
%define CONFIG_HEVC_DEMUXER 1
%define CONFIG_HLS_DEMUXER 1
%define CONFIG_HNM_DEMUXER 1
%define CONFIG_ICO_DEMUXER 1
%define CONFIG_IDCIN_DEMUXER 1
%define CONFIG_IDF_DEMUXER 1
%define CONFIG_IFF_DEMUXER 1
%define CONFIG_IFV_DEMUXER 1
%define CONFIG_ILBC_DEMUXER 1
%define CONFIG_IMAGE2_DEMUXER 1
%define CONFIG_IMAGE2PIPE_DEMUXER 1
%define CONFIG_IMAGE2_ALIAS_PIX_DEMUXER 1
%define CONFIG_IMAGE2_BRENDER_PIX_DEMUXER 1
%define CONFIG_INGENIENT_DEMUXER 1
%define CONFIG_IPMOVIE_DEMUXER 1
%define CONFIG_IRCAM_DEMUXER 1
%define CONFIG_ISS_DEMUXER 1
%define CONFIG_IV8_DEMUXER 1
%define CONFIG_IVF_DEMUXER 1
%define CONFIG_IVR_DEMUXER 1
%define CONFIG_JACOSUB_DEMUXER 1
%define CONFIG_JV_DEMUXER 1
%define CONFIG_KUX_DEMUXER 1
%define CONFIG_LMLM4_DEMUXER 1
%define CONFIG_LOAS_DEMUXER 1
%define CONFIG_LRC_DEMUXER 1
%define CONFIG_LVF_DEMUXER 1
%define CONFIG_LXF_DEMUXER 1
%define CONFIG_M4V_DEMUXER 1
%define CONFIG_MATROSKA_DEMUXER 1
%define CONFIG_MGSTS_DEMUXER 1
%define CONFIG_MICRODVD_DEMUXER 1
%define CONFIG_MJPEG_DEMUXER 1
%define CONFIG_MJPEG_2000_DEMUXER 1
%define CONFIG_MLP_DEMUXER 1
%define CONFIG_MLV_DEMUXER 1
%define CONFIG_MM_DEMUXER 1
%define CONFIG_MMF_DEMUXER 1
%define CONFIG_MOV_DEMUXER 1
%define CONFIG_MP3_DEMUXER 1
%define CONFIG_MPC_DEMUXER 1
%define CONFIG_MPC8_DEMUXER 1
%define CONFIG_MPEGPS_DEMUXER 1
%define CONFIG_MPEGTS_DEMUXER 1
%define CONFIG_MPEGTSRAW_DEMUXER 1
%define CONFIG_MPEGVIDEO_DEMUXER 1
%define CONFIG_MPJPEG_DEMUXER 1
%define CONFIG_MPL2_DEMUXER 1
%define CONFIG_MPSUB_DEMUXER 1
%define CONFIG_MSF_DEMUXER 1
%define CONFIG_MSNWC_TCP_DEMUXER 1
%define CONFIG_MTAF_DEMUXER 1
%define CONFIG_MTV_DEMUXER 1
%define CONFIG_MUSX_DEMUXER 1
%define CONFIG_MV_DEMUXER 1
%define CONFIG_MVI_DEMUXER 1
%define CONFIG_MXF_DEMUXER 1
%define CONFIG_MXG_DEMUXER 1
%define CONFIG_NC_DEMUXER 1
%define CONFIG_NISTSPHERE_DEMUXER 1
%define CONFIG_NSP_DEMUXER 1
%define CONFIG_NSV_DEMUXER 1
%define CONFIG_NUT_DEMUXER 1
%define CONFIG_NUV_DEMUXER 1
%define CONFIG_OGG_DEMUXER 1
%define CONFIG_OMA_DEMUXER 1
%define CONFIG_PAF_DEMUXER 1
%define CONFIG_PCM_ALAW_DEMUXER 1
%define CONFIG_PCM_MULAW_DEMUXER 1
%define CONFIG_PCM_VIDC_DEMUXER 1
%define CONFIG_PCM_F64BE_DEMUXER 1
%define CONFIG_PCM_F64LE_DEMUXER 1
%define CONFIG_PCM_F32BE_DEMUXER 1
%define CONFIG_PCM_F32LE_DEMUXER 1
%define CONFIG_PCM_S32BE_DEMUXER 1
%define CONFIG_PCM_S32LE_DEMUXER 1
%define CONFIG_PCM_S24BE_DEMUXER 1
%define CONFIG_PCM_S24LE_DEMUXER 1
%define CONFIG_PCM_S16BE_DEMUXER 1
%define CONFIG_PCM_S16LE_DEMUXER 1
%define CONFIG_PCM_S8_DEMUXER 1
%define CONFIG_PCM_U32BE_DEMUXER 1
%define CONFIG_PCM_U32LE_DEMUXER 1
%define CONFIG_PCM_U24BE_DEMUXER 1
%define CONFIG_PCM_U24LE_DEMUXER 1
%define CONFIG_PCM_U16BE_DEMUXER 1
%define CONFIG_PCM_U16LE_DEMUXER 1
%define CONFIG_PCM_U8_DEMUXER 1
%define CONFIG_PJS_DEMUXER 1
%define CONFIG_PMP_DEMUXER 1
%define CONFIG_PVA_DEMUXER 1
%define CONFIG_PVF_DEMUXER 1
%define CONFIG_QCP_DEMUXER 1
%define CONFIG_R3D_DEMUXER 1
%define CONFIG_RAWVIDEO_DEMUXER 1
%define CONFIG_REALTEXT_DEMUXER 1
%define CONFIG_REDSPARK_DEMUXER 1
%define CONFIG_RL2_DEMUXER 1
%define CONFIG_RM_DEMUXER 1
%define CONFIG_ROQ_DEMUXER 1
%define CONFIG_RPL_DEMUXER 1
%define CONFIG_RSD_DEMUXER 1
%define CONFIG_RSO_DEMUXER 1
%define CONFIG_RTP_DEMUXER 1
%define CONFIG_RTSP_DEMUXER 1
%define CONFIG_S337M_DEMUXER 1
%define CONFIG_SAMI_DEMUXER 1
%define CONFIG_SAP_DEMUXER 1
%define CONFIG_SBC_DEMUXER 1
%define CONFIG_SBG_DEMUXER 1
%define CONFIG_SCC_DEMUXER 1
%define CONFIG_SDP_DEMUXER 1
%define CONFIG_SDR2_DEMUXER 1
%define CONFIG_SDS_DEMUXER 1
%define CONFIG_SDX_DEMUXER 1
%define CONFIG_SEGAFILM_DEMUXER 1
%define CONFIG_SER_DEMUXER 1
%define CONFIG_SHORTEN_DEMUXER 1
%define CONFIG_SIFF_DEMUXER 1
%define CONFIG_SLN_DEMUXER 1
%define CONFIG_SMACKER_DEMUXER 1
%define CONFIG_SMJPEG_DEMUXER 1
%define CONFIG_SMUSH_DEMUXER 1
%define CONFIG_SOL_DEMUXER 1
%define CONFIG_SOX_DEMUXER 1
%define CONFIG_SPDIF_DEMUXER 1
%define CONFIG_SRT_DEMUXER 1
%define CONFIG_STR_DEMUXER 1
%define CONFIG_STL_DEMUXER 1
%define CONFIG_SUBVIEWER1_DEMUXER 1
%define CONFIG_SUBVIEWER_DEMUXER 1
%define CONFIG_SUP_DEMUXER 1
%define CONFIG_SVAG_DEMUXER 1
%define CONFIG_SWF_DEMUXER 1
%define CONFIG_TAK_DEMUXER 1
%define CONFIG_TEDCAPTIONS_DEMUXER 1
%define CONFIG_THP_DEMUXER 1
%define CONFIG_THREEDOSTR_DEMUXER 1
%define CONFIG_TIERTEXSEQ_DEMUXER 1
%define CONFIG_TMV_DEMUXER 1
%define CONFIG_TRUEHD_DEMUXER 1
%define CONFIG_TTA_DEMUXER 1
%define CONFIG_TXD_DEMUXER 1
%define CONFIG_TTY_DEMUXER 1
%define CONFIG_TY_DEMUXER 1
%define CONFIG_V210_DEMUXER 1
%define CONFIG_V210X_DEMUXER 1
%define CONFIG_VAG_DEMUXER 1
%define CONFIG_VC1_DEMUXER 1
%define CONFIG_VC1T_DEMUXER 1
%define CONFIG_VIVIDAS_DEMUXER 1
%define CONFIG_VIVO_DEMUXER 1
%define CONFIG_VMD_DEMUXER 1
%define CONFIG_VOBSUB_DEMUXER 1
%define CONFIG_VOC_DEMUXER 1
%define CONFIG_VPK_DEMUXER 1
%define CONFIG_VPLAYER_DEMUXER 1
%define CONFIG_VQF_DEMUXER 1
%define CONFIG_W64_DEMUXER 1
%define CONFIG_WAV_DEMUXER 1
%define CONFIG_WC3_DEMUXER 1
%define CONFIG_WEBM_DASH_MANIFEST_DEMUXER 1
%define CONFIG_WEBVTT_DEMUXER 1
%define CONFIG_WSAUD_DEMUXER 1
%define CONFIG_WSD_DEMUXER 1
%define CONFIG_WSVQA_DEMUXER 1
%define CONFIG_WTV_DEMUXER 1
%define CONFIG_WVE_DEMUXER 1
%define CONFIG_WV_DEMUXER 1
%define CONFIG_XA_DEMUXER 1
%define CONFIG_XBIN_DEMUXER 1
%define CONFIG_XMV_DEMUXER 1
%define CONFIG_XVAG_DEMUXER 1
%define CONFIG_XWMA_DEMUXER 1
%define CONFIG_YOP_DEMUXER 1
%define CONFIG_YUV4MPEGPIPE_DEMUXER 1
%define CONFIG_IMAGE_BMP_PIPE_DEMUXER 1
%define CONFIG_IMAGE_DDS_PIPE_DEMUXER 1
%define CONFIG_IMAGE_DPX_PIPE_DEMUXER 1
%define CONFIG_IMAGE_EXR_PIPE_DEMUXER 1
%define CONFIG_IMAGE_GIF_PIPE_DEMUXER 1
%define CONFIG_IMAGE_J2K_PIPE_DEMUXER 1
%define CONFIG_IMAGE_JPEG_PIPE_DEMUXER 1
%define CONFIG_IMAGE_JPEGLS_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PAM_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PBM_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PCX_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PGMYUV_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PGM_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PICTOR_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PNG_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PPM_PIPE_DEMUXER 1
%define CONFIG_IMAGE_PSD_PIPE_DEMUXER 1
%define CONFIG_IMAGE_QDRAW_PIPE_DEMUXER 1
%define CONFIG_IMAGE_SGI_PIPE_DEMUXER 1
%define CONFIG_IMAGE_SVG_PIPE_DEMUXER 1
%define CONFIG_IMAGE_SUNRAST_PIPE_DEMUXER 1
%define CONFIG_IMAGE_TIFF_PIPE_DEMUXER 1
%define CONFIG_IMAGE_WEBP_PIPE_DEMUXER 1
%define CONFIG_IMAGE_XPM_PIPE_DEMUXER 1
%define CONFIG_IMAGE_XWD_PIPE_DEMUXER 1
%define CONFIG_LIBGME_DEMUXER 0
%define CONFIG_LIBMODPLUG_DEMUXER 0
%define CONFIG_LIBOPENMPT_DEMUXER 0
%define CONFIG_VAPOURSYNTH_DEMUXER 0
%define CONFIG_A64_MUXER 1
%define CONFIG_AC3_MUXER 1
%define CONFIG_ADTS_MUXER 1
%define CONFIG_ADX_MUXER 1
%define CONFIG_AIFF_MUXER 1
%define CONFIG_AMR_MUXER 1
%define CONFIG_APNG_MUXER 1
%define CONFIG_APTX_MUXER 1
%define CONFIG_APTX_HD_MUXER 1
%define CONFIG_ASF_MUXER 1
%define CONFIG_ASS_MUXER 1
%define CONFIG_AST_MUXER 1
%define CONFIG_ASF_STREAM_MUXER 1
%define CONFIG_AU_MUXER 1
%define CONFIG_AVI_MUXER 1
%define CONFIG_AVM2_MUXER 1
%define CONFIG_AVS2_MUXER 1
%define CONFIG_BIT_MUXER 1
%define CONFIG_CAF_MUXER 1
%define CONFIG_CAVSVIDEO_MUXER 1
%define CONFIG_CODEC2_MUXER 1
%define CONFIG_CODEC2RAW_MUXER 1
%define CONFIG_CRC_MUXER 1
%define CONFIG_DASH_MUXER 1
%define CONFIG_DATA_MUXER 1
%define CONFIG_DAUD_MUXER 1
%define CONFIG_DIRAC_MUXER 1
%define CONFIG_DNXHD_MUXER 1
%define CONFIG_DTS_MUXER 1
%define CONFIG_DV_MUXER 1
%define CONFIG_EAC3_MUXER 1
%define CONFIG_F4V_MUXER 1
%define CONFIG_FFMETADATA_MUXER 1
%define CONFIG_FIFO_MUXER 1
%define CONFIG_FIFO_TEST_MUXER 1
%define CONFIG_FILMSTRIP_MUXER 1
%define CONFIG_FITS_MUXER 1
%define CONFIG_FLAC_MUXER 1
%define CONFIG_FLV_MUXER 1
%define CONFIG_FRAMECRC_MUXER 1
%define CONFIG_FRAMEHASH_MUXER 1
%define CONFIG_FRAMEMD5_MUXER 1
%define CONFIG_G722_MUXER 1
%define CONFIG_G723_1_MUXER 1
%define CONFIG_G726_MUXER 1
%define CONFIG_G726LE_MUXER 1
%define CONFIG_GIF_MUXER 1
%define CONFIG_GSM_MUXER 1
%define CONFIG_GXF_MUXER 1
%define CONFIG_H261_MUXER 1
%define CONFIG_H263_MUXER 1
%define CONFIG_H264_MUXER 1
%define CONFIG_HASH_MUXER 1
%define CONFIG_HDS_MUXER 1
%define CONFIG_HEVC_MUXER 1
%define CONFIG_HLS_MUXER 1
%define CONFIG_ICO_MUXER 1
%define CONFIG_ILBC_MUXER 1
%define CONFIG_IMAGE2_MUXER 1
%define CONFIG_IMAGE2PIPE_MUXER 1
%define CONFIG_IPOD_MUXER 1
%define CONFIG_IRCAM_MUXER 1
%define CONFIG_ISMV_MUXER 1
%define CONFIG_IVF_MUXER 1
%define CONFIG_JACOSUB_MUXER 1
%define CONFIG_LATM_MUXER 1
%define CONFIG_LRC_MUXER 1
%define CONFIG_M4V_MUXER 1
%define CONFIG_MD5_MUXER 1
%define CONFIG_MATROSKA_MUXER 1
%define CONFIG_MATROSKA_AUDIO_MUXER 1
%define CONFIG_MICRODVD_MUXER 1
%define CONFIG_MJPEG_MUXER 1
%define CONFIG_MLP_MUXER 1
%define CONFIG_MMF_MUXER 1
%define CONFIG_MOV_MUXER 1
%define CONFIG_MP2_MUXER 1
%define CONFIG_MP3_MUXER 1
%define CONFIG_MP4_MUXER 1
%define CONFIG_MPEG1SYSTEM_MUXER 1
%define CONFIG_MPEG1VCD_MUXER 1
%define CONFIG_MPEG1VIDEO_MUXER 1
%define CONFIG_MPEG2DVD_MUXER 1
%define CONFIG_MPEG2SVCD_MUXER 1
%define CONFIG_MPEG2VIDEO_MUXER 1
%define CONFIG_MPEG2VOB_MUXER 1
%define CONFIG_MPEGTS_MUXER 1
%define CONFIG_MPJPEG_MUXER 1
%define CONFIG_MXF_MUXER 1
%define CONFIG_MXF_D10_MUXER 1
%define CONFIG_MXF_OPATOM_MUXER 1
%define CONFIG_NULL_MUXER 1
%define CONFIG_NUT_MUXER 1
%define CONFIG_OGA_MUXER 1
%define CONFIG_OGG_MUXER 1
%define CONFIG_OGV_MUXER 1
%define CONFIG_OMA_MUXER 1
%define CONFIG_OPUS_MUXER 1
%define CONFIG_PCM_ALAW_MUXER 1
%define CONFIG_PCM_MULAW_MUXER 1
%define CONFIG_PCM_VIDC_MUXER 1
%define CONFIG_PCM_F64BE_MUXER 1
%define CONFIG_PCM_F64LE_MUXER 1
%define CONFIG_PCM_F32BE_MUXER 1
%define CONFIG_PCM_F32LE_MUXER 1
%define CONFIG_PCM_S32BE_MUXER 1
%define CONFIG_PCM_S32LE_MUXER 1
%define CONFIG_PCM_S24BE_MUXER 1
%define CONFIG_PCM_S24LE_MUXER 1
%define CONFIG_PCM_S16BE_MUXER 1
%define CONFIG_PCM_S16LE_MUXER 1
%define CONFIG_PCM_S8_MUXER 1
%define CONFIG_PCM_U32BE_MUXER 1
%define CONFIG_PCM_U32LE_MUXER 1
%define CONFIG_PCM_U24BE_MUXER 1
%define CONFIG_PCM_U24LE_MUXER 1
%define CONFIG_PCM_U16BE_MUXER 1
%define CONFIG_PCM_U16LE_MUXER 1
%define CONFIG_PCM_U8_MUXER 1
%define CONFIG_PSP_MUXER 1
%define CONFIG_RAWVIDEO_MUXER 1
%define CONFIG_RM_MUXER 1
%define CONFIG_ROQ_MUXER 1
%define CONFIG_RSO_MUXER 1
%define CONFIG_RTP_MUXER 1
%define CONFIG_RTP_MPEGTS_MUXER 1
%define CONFIG_RTSP_MUXER 1
%define CONFIG_SAP_MUXER 1
%define CONFIG_SBC_MUXER 1
%define CONFIG_SCC_MUXER 1
%define CONFIG_SEGAFILM_MUXER 1
%define CONFIG_SEGMENT_MUXER 1
%define CONFIG_STREAM_SEGMENT_MUXER 1
%define CONFIG_SINGLEJPEG_MUXER 1
%define CONFIG_SMJPEG_MUXER 1
%define CONFIG_SMOOTHSTREAMING_MUXER 1
%define CONFIG_SOX_MUXER 1
%define CONFIG_SPX_MUXER 1
%define CONFIG_SPDIF_MUXER 1
%define CONFIG_SRT_MUXER 1
%define CONFIG_SUP_MUXER 1
%define CONFIG_SWF_MUXER 1
%define CONFIG_TEE_MUXER 1
%define CONFIG_TG2_MUXER 1
%define CONFIG_TGP_MUXER 1
%define CONFIG_MKVTIMESTAMP_V2_MUXER 1
%define CONFIG_TRUEHD_MUXER 1
%define CONFIG_TTA_MUXER 1
%define CONFIG_UNCODEDFRAMECRC_MUXER 1
%define CONFIG_VC1_MUXER 1
%define CONFIG_VC1T_MUXER 1
%define CONFIG_VOC_MUXER 1
%define CONFIG_W64_MUXER 1
%define CONFIG_WAV_MUXER 1
%define CONFIG_WEBM_MUXER 1
%define CONFIG_WEBM_DASH_MANIFEST_MUXER 1
%define CONFIG_WEBM_CHUNK_MUXER 1
%define CONFIG_WEBP_MUXER 1
%define CONFIG_WEBVTT_MUXER 1
%define CONFIG_WTV_MUXER 1
%define CONFIG_WV_MUXER 1
%define CONFIG_YUV4MPEGPIPE_MUXER 1
%define CONFIG_CHROMAPRINT_MUXER 0
%define CONFIG_ASYNC_PROTOCOL 1
%define CONFIG_BLURAY_PROTOCOL 0
%define CONFIG_CACHE_PROTOCOL 1
%define CONFIG_CONCAT_PROTOCOL 1
%define CONFIG_CRYPTO_PROTOCOL 1
%define CONFIG_DATA_PROTOCOL 1
%define CONFIG_FFRTMPCRYPT_PROTOCOL 0
%define CONFIG_FFRTMPHTTP_PROTOCOL 1
%define CONFIG_FILE_PROTOCOL 1
%define CONFIG_FTP_PROTOCOL 1
%define CONFIG_GOPHER_PROTOCOL 1
%define CONFIG_HLS_PROTOCOL 1
%define CONFIG_HTTP_PROTOCOL 1
%define CONFIG_HTTPPROXY_PROTOCOL 1
%define CONFIG_HTTPS_PROTOCOL 1
%define CONFIG_ICECAST_PROTOCOL 1
%define CONFIG_MMSH_PROTOCOL 1
%define CONFIG_MMST_PROTOCOL 1
%define CONFIG_MD5_PROTOCOL 1
%define CONFIG_PIPE_PROTOCOL 1
%define CONFIG_PROMPEG_PROTOCOL 1
%define CONFIG_RTMP_PROTOCOL 1
%define CONFIG_RTMPE_PROTOCOL 0
%define CONFIG_RTMPS_PROTOCOL 1
%define CONFIG_RTMPT_PROTOCOL 1
%define CONFIG_RTMPTE_PROTOCOL 0
%define CONFIG_RTMPTS_PROTOCOL 1
%define CONFIG_RTP_PROTOCOL 1
%define CONFIG_SCTP_PROTOCOL 0
%define CONFIG_SRTP_PROTOCOL 1
%define CONFIG_SUBFILE_PROTOCOL 1
%define CONFIG_TEE_PROTOCOL 1
%define CONFIG_TCP_PROTOCOL 1
%define CONFIG_TLS_PROTOCOL 1
%define CONFIG_UDP_PROTOCOL 1
%define CONFIG_UDPLITE_PROTOCOL 1
%define CONFIG_UNIX_PROTOCOL 1
%define CONFIG_LIBRTMP_PROTOCOL 0
%define CONFIG_LIBRTMPE_PROTOCOL 0
%define CONFIG_LIBRTMPS_PROTOCOL 0
%define CONFIG_LIBRTMPT_PROTOCOL 0
%define CONFIG_LIBRTMPTE_PROTOCOL 0
%define CONFIG_LIBSRT_PROTOCOL 0
%define CONFIG_LIBSSH_PROTOCOL 0
%define CONFIG_LIBSMBCLIENT_PROTOCOL 0
|
/*
This file is a part of libcds - Concurrent Data Structures library
(C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
Source code repo: http://github.com/khizmax/libcds/
Download: http://sourceforge.net/projects/libcds/files/
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "test_intrusive_feldman_hashset_hp.h"
#include <cds/intrusive/feldman_hashset_dhp.h>
namespace {
namespace ci = cds::intrusive;
typedef cds::gc::DHP gc_type;
class IntrusiveFeldmanHashSet_DHP : public cds_test::intrusive_feldman_hashset_hp
{
protected:
typedef cds_test::intrusive_feldman_hashset_hp base_class;
protected:
void SetUp()
{
typedef ci::FeldmanHashSet< gc_type, int_item,
typename ci::feldman_hashset::make_traits<
ci::feldman_hashset::hash_accessor< hash_accessor >
,ci::opt::less< std::less<int>>
,ci::opt::disposer<mock_disposer>
>::type
> set_type;
cds::gc::dhp::GarbageCollector::Construct( 16, set_type::c_nHazardPtrCount );
cds::threading::Manager::attachThread();
}
void TearDown()
{
cds::threading::Manager::detachThread();
cds::gc::dhp::GarbageCollector::Destruct();
}
};
TEST_F( IntrusiveFeldmanHashSet_DHP, compare )
{
struct traits : public ci::feldman_hashset::traits
{
typedef base_class::hash_accessor hash_accessor;
typedef cmp compare;
typedef mock_disposer disposer;
};
typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type;
set_type s;
test( s );
}
TEST_F( IntrusiveFeldmanHashSet_DHP, less )
{
typedef ci::FeldmanHashSet< gc_type, int_item,
typename ci::feldman_hashset::make_traits<
ci::feldman_hashset::hash_accessor< hash_accessor >
, ci::opt::less< std::less<int>>
, ci::opt::disposer<mock_disposer>
>::type
> set_type;
set_type s( 5, 2 );
test( s );
}
TEST_F( IntrusiveFeldmanHashSet_DHP, cmpmix )
{
struct traits : public ci::feldman_hashset::traits
{
typedef base_class::hash_accessor hash_accessor;
typedef cmp compare;
typedef std::less<int> less;
typedef mock_disposer disposer;
typedef simple_item_counter item_counter;
};
typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type;
set_type s( 3, 4 );
test( s );
}
TEST_F( IntrusiveFeldmanHashSet_DHP, backoff )
{
struct traits : public ci::feldman_hashset::traits
{
typedef base_class::hash_accessor hash_accessor;
typedef cmp compare;
typedef mock_disposer disposer;
typedef cds::backoff::empty back_off;
typedef ci::opt::v::sequential_consistent memory_model;
};
typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type;
set_type s( 8, 3 );
test( s );
}
TEST_F( IntrusiveFeldmanHashSet_DHP, stat )
{
struct traits : public ci::feldman_hashset::traits
{
typedef base_class::hash_accessor hash_accessor;
typedef cmp compare;
typedef mock_disposer disposer;
typedef ci::feldman_hashset::stat<> stat;
};
typedef ci::FeldmanHashSet< gc_type, int_item, traits > set_type;
set_type s( 8, 3 );
test( s );
}
TEST_F( IntrusiveFeldmanHashSet_DHP, explicit_hash_size )
{
struct traits: public ci::feldman_hashset::traits
{
typedef base_class::hash_accessor2 hash_accessor;
enum: size_t {
hash_size = sizeof( std::declval<key_val>().nKey )
};
typedef base_class::cmp2 compare;
typedef mock_disposer disposer;
typedef ci::feldman_hashset::stat<> stat;
};
typedef ci::FeldmanHashSet< gc_type, int_item2, traits > set_type;
set_type s( 8, 3 );
test( s );
}
} // namespace
|
/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2007 Giorgio Facchinetti
Copyright (C) 2007 Cristina Duminuco
Copyright (C) 2011 Ferdinando Ametrano
Copyright (C) 2015 Peter Caspers
This file is part of QuantLib, a free-software/open-source library
for financial quantitative analysts and developers - http://quantlib.org/
QuantLib is free software: you can redistribute it and/or modify it
under the terms of the QuantLib license. You should have received a
copy of the license along with this program; if not, please email
<quantlib-dev@lists.sf.net>. The license is also available online at
<http://quantlib.org/license.shtml>.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
/*! \file couponpricer.hpp
\brief Coupon pricers
*/
#ifndef quantlib_coupon_pricer_hpp
#define quantlib_coupon_pricer_hpp
#include <ql/termstructures/volatility/optionlet/optionletvolatilitystructure.hpp>
#include <ql/termstructures/volatility/swaption/swaptionvolstructure.hpp>
#include <ql/indexes/iborindex.hpp>
#include <ql/cashflow.hpp>
#include <ql/option.hpp>
#include <ql/quotes/simplequote.hpp>
namespace QuantLib {
class FloatingRateCoupon;
class IborCoupon;
//! generic pricer for floating-rate coupons
class FloatingRateCouponPricer: public virtual Observer,
public virtual Observable {
public:
virtual ~FloatingRateCouponPricer() {}
//! \name required interface
//@{
virtual Real swapletPrice() const = 0;
virtual Rate swapletRate() const = 0;
virtual Real capletPrice(Rate effectiveCap) const = 0;
virtual Rate capletRate(Rate effectiveCap) const = 0;
virtual Real floorletPrice(Rate effectiveFloor) const = 0;
virtual Rate floorletRate(Rate effectiveFloor) const = 0;
virtual void initialize(const FloatingRateCoupon& coupon) = 0;
//@}
//! \name Observer interface
//@{
void update(){notifyObservers();}
//@}
};
//! base pricer for capped/floored Ibor coupons
class IborCouponPricer : public FloatingRateCouponPricer {
public:
IborCouponPricer(const Handle<OptionletVolatilityStructure>& v =
Handle<OptionletVolatilityStructure>())
: capletVol_(v) { registerWith(capletVol_); }
Handle<OptionletVolatilityStructure> capletVolatility() const{
return capletVol_;
}
void setCapletVolatility(
const Handle<OptionletVolatilityStructure>& v =
Handle<OptionletVolatilityStructure>()) {
unregisterWith(capletVol_);
capletVol_ = v;
registerWith(capletVol_);
update();
}
private:
Handle<OptionletVolatilityStructure> capletVol_;
};
/*! Black-formula pricer for capped/floored Ibor coupons
References for timing adjustments
Black76 Hull, Options, Futures and other
derivatives, 4th ed., page 550
BivariateLognormal http://ssrn.com/abstract=2170721
The bivariate lognormal adjustment implementation is
still considered experimental */
class BlackIborCouponPricer : public IborCouponPricer {
public:
enum TimingAdjustment { Black76, BivariateLognormal };
BlackIborCouponPricer(
const Handle< OptionletVolatilityStructure > &v =
Handle< OptionletVolatilityStructure >(),
const TimingAdjustment timingAdjustment = Black76,
const Handle< Quote > correlation =
Handle< Quote >(std::make_shared<SimpleQuote>(1.0)))
: IborCouponPricer(v), timingAdjustment_(timingAdjustment),
correlation_(correlation) {
QL_REQUIRE(timingAdjustment_ == Black76 ||
timingAdjustment_ == BivariateLognormal,
"unknown timing adjustment (code " << timingAdjustment_
<< ")");
registerWith(correlation_);
}
virtual void initialize(const FloatingRateCoupon& coupon);
Real swapletPrice() const;
Rate swapletRate() const;
Real capletPrice(Rate effectiveCap) const;
Rate capletRate(Rate effectiveCap) const;
Real floorletPrice(Rate effectiveFloor) const;
Rate floorletRate(Rate effectiveFloor) const;
protected:
Real optionletPrice(Option::Type optionType,
Real effStrike) const;
virtual Rate adjustedFixing(Rate fixing = Null<Rate>()) const;
Real gearing_;
Spread spread_;
Time accrualPeriod_;
std::shared_ptr<IborIndex> index_;
Real discount_;
Real spreadLegValue_;
const FloatingRateCoupon* coupon_;
private:
const TimingAdjustment timingAdjustment_;
const Handle< Quote > correlation_;
};
//! base pricer for vanilla CMS coupons
class CmsCouponPricer : public FloatingRateCouponPricer {
public:
CmsCouponPricer(const Handle<SwaptionVolatilityStructure>& v =
Handle<SwaptionVolatilityStructure>())
: swaptionVol_(v) { registerWith(swaptionVol_); }
Handle<SwaptionVolatilityStructure> swaptionVolatility() const{
return swaptionVol_;
}
void setSwaptionVolatility(
const Handle<SwaptionVolatilityStructure>& v=
Handle<SwaptionVolatilityStructure>()) {
unregisterWith(swaptionVol_);
swaptionVol_ = v;
registerWith(swaptionVol_);
update();
}
private:
Handle<SwaptionVolatilityStructure> swaptionVol_;
};
/*! (CMS) coupon pricer that has a mean reversion parameter which can be
used to calibrate to cms market quotes */
class MeanRevertingPricer {
public:
virtual Real meanReversion() const = 0;
virtual void setMeanReversion(const Handle<Quote>&) = 0;
virtual ~MeanRevertingPricer() {}
};
void setCouponPricer(const Leg& leg,
const std::shared_ptr<FloatingRateCouponPricer>&);
void setCouponPricers(
const Leg& leg,
const std::vector<std::shared_ptr<FloatingRateCouponPricer> >&);
/*! set the first matching pricer (if any) to each coupon of the leg */
void setCouponPricers(
const Leg& leg,
const std::shared_ptr<FloatingRateCouponPricer>&,
const std::shared_ptr<FloatingRateCouponPricer>&);
void setCouponPricers(
const Leg& leg,
const std::shared_ptr<FloatingRateCouponPricer>&,
const std::shared_ptr<FloatingRateCouponPricer>&,
const std::shared_ptr<FloatingRateCouponPricer>&);
void setCouponPricers(
const Leg& leg,
const std::shared_ptr<FloatingRateCouponPricer>&,
const std::shared_ptr<FloatingRateCouponPricer>&,
const std::shared_ptr<FloatingRateCouponPricer>&,
const std::shared_ptr<FloatingRateCouponPricer>&);
// inline
inline Real BlackIborCouponPricer::swapletPrice() const {
// past or future fixing is managed in InterestRateIndex::fixing()
Real swapletPrice = adjustedFixing() * accrualPeriod_ * discount_;
return gearing_ * swapletPrice + spreadLegValue_;
}
inline Rate BlackIborCouponPricer::swapletRate() const {
return swapletPrice()/(accrualPeriod_*discount_);
}
inline Real BlackIborCouponPricer::capletPrice(Rate effectiveCap) const {
Real capletPrice = optionletPrice(Option::Call, effectiveCap);
return gearing_ * capletPrice;
}
inline Rate BlackIborCouponPricer::capletRate(Rate effectiveCap) const {
return capletPrice(effectiveCap) / (accrualPeriod_*discount_);
}
inline
Real BlackIborCouponPricer::floorletPrice(Rate effectiveFloor) const {
Real floorletPrice = optionletPrice(Option::Put, effectiveFloor);
return gearing_ * floorletPrice;
}
inline
Rate BlackIborCouponPricer::floorletRate(Rate effectiveFloor) const {
return floorletPrice(effectiveFloor) / (accrualPeriod_*discount_);
}
}
#endif
|
; A079319: a(0) = 1; for n > 1, a(n) = 4*a(n-1) - (2^n-1).
; 1,3,9,29,101,373,1429,5589,22101,87893,350549,1400149,5596501,22377813,89494869,357946709,1431721301,5726754133,22906754389,91626493269,366504924501,1466017600853,5864066209109,23456256447829
mov $1,2
pow $1,$0
add $1,2
bin $1,2
sub $1,3
div $1,3
mul $1,2
add $1,1
|
// Copyright (C) 2018-2022 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <vector>
#include "single_layer_tests/mat_mul.hpp"
using namespace LayerTestsDefinitions;
namespace {
const std::vector<InferenceEngine::Precision> inputPrecisions = {
InferenceEngine::Precision::FP32
};
const std::vector<ShapeRelatedParams> shapeRelatedParams = {
{ { {5, 1}, true }, { {5, 1}, false } },
{ { {1, 5}, false }, { {1, 5}, true } },
{ { {5}, false }, { {5}, false } },
{ { {5}, true }, { {5}, true } }
};
std::vector<ngraph::helpers::InputLayerType> secondaryInputTypes = {
ngraph::helpers::InputLayerType::CONSTANT
};
std::map<std::string, std::string> additional_config = {{"GNA_DEVICE_MODE", "GNA_SW_EXACT"}};
INSTANTIATE_TEST_SUITE_P(smoke_MatMul, MatMulTest,
::testing::Combine(
::testing::ValuesIn(shapeRelatedParams),
::testing::ValuesIn(inputPrecisions),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
::testing::Values(InferenceEngine::Layout::ANY),
::testing::ValuesIn(secondaryInputTypes),
::testing::Values(CommonTestUtils::DEVICE_GNA),
::testing::Values(additional_config)),
MatMulTest::getTestCaseName);
} // namespace |
bits 64
section .rodata
global _<name>_start
global _<name>_end
global _<name>_size
_<name>_start: incbin "<bin>"
_<name>_end:
_<name>_size: dd $ - _<name>_start
|
#include "../inc/Vertex.h"
namespace galg {
/*private*/
// Constructor
Vertex::Vertex(const std::pair<int,int>& coord,
const int& size,
const std::string& label,
const VertexShape& shape,
const boost::uuids::uuid& id):
Widget(coord, {size, size}, id),
m_label(label),
m_shape(shape)
{
set_gui_state("mainMenu", false);
set_gui_state("modifyLabel", false);
set_gui_state("modifyVertexShape", false);
}
Vertex::Vertex(const std::pair<int,int>& coord,
const std::pair<int,int>& dim,
const std::string& label,
const VertexShape& shape,
const boost::uuids::uuid& id):
Widget(coord, dim, id),
m_label(label),
m_shape(shape)
{
set_gui_state("mainMenu", false);
set_gui_state("modifyLabel", false);
set_gui_state("modifyVertexShape", false);
}
Vertex::Vertex(const Vertex& vertex):
Widget(vertex.get_coord(), vertex.get_dim()),
m_label(vertex.get_label()),
m_shape(vertex.get_shape())
{
set_gui_state("mainMenu", false);
set_gui_state("modifyLabel", false);
set_gui_state("modifyVertexShape", false);
}
Vertex::Vertex():
Widget(),
m_label(std::string()),
m_shape(VertexShape::CIRCLE)
{
set_gui_state("mainMenu", false);
set_gui_state("modifyLabel", false);
set_gui_state("modifyVertexShape", false);
}
// Getter
const VertexShape& Vertex::get_shape() const {
return m_shape;
}
const std::string& Vertex::get_label() const {
return m_label;
}
// Setter
void Vertex::set_shape(const VertexShape& shape) {
m_shape = shape;
}
void Vertex::set_label(const std::string& label) {
m_label = label;
}
// Draw/Update
void Vertex::draw(ModifiedPGE& engine) const {
int label_x = get_x() + get_width() / 2 - (get_label().size() / 2) * 8 - (get_label().size() % 2) * 4;
int label_y = get_y() + get_width() / 2 - 4;
std::string state = get_is_drag() ? "_drag" :
is_mouse_over(engine) ? "_over" : "";
olc::Pixel bg = get_color("bg" + state);
olc::Pixel fg = get_color("fg" + state);
olc::Pixel border = get_color("border" + state);
switch(m_shape) {
case VertexShape::CIRCLE:
engine.FillCircle(get_x() + get_width() / 2,
get_y() + get_width() / 2,
get_width() / 2,
bg);
engine.DrawCircle(get_x() + get_width() / 2,
get_y() + get_width() / 2,
get_width() / 2,
border);
engine.DrawString(label_x,
label_y,
get_label(),
fg);
break;
case VertexShape::RECTANGLE:
engine.FillRect(get_x(),
get_y(),
get_width(),
get_height(),
bg);
engine.DrawRect(get_x(),
get_y(),
get_width(),
get_height(),
border);
engine.DrawString(label_x,
label_y,
get_label(),
fg);
break;
case VertexShape::DIAMOND:
// TODO: implement diamond shape.
break;
}
}
void Vertex::update(ModifiedPGE& engine) {
if(is_clicked(engine, 0)) {
toggle_drag_on(engine);
engine.DrawString(0, 0, "DRAG ON");
}
if(get_is_drag()) {
drag(engine.GetMouseX(), engine.GetMouseY());
if(engine.GetMouse(0).bReleased) {
toggle_drag_off(engine);
}
}
if(is_clicked(engine, 1) && !engine.get_flag("has_active_popup_menu")) {
engine.set_flag("has_active_popup_menu", true);
set_gui_state("mainMenu", true);
set_mouse_pos({engine.GetMouseX() * engine.GetPixelSize().x,
engine.GetMouseY() * engine.GetPixelSize().y});
}
}
void Vertex::update_ui(ModifiedPGE& engine) {
if(get_gui_state("mainMenu")) {
main_menu(engine);
}
if(get_gui_state("modifyLabel")) {
modify_label(engine);
}
if(get_gui_state("modifyVertexShape")) {
modify_shape(engine);
}
if(get_gui_state("modifyDepth")) {
Widget::modify_depth(engine);
}
}
// State
bool Vertex::is_mouse_over(ModifiedPGE& engine) const {
int mouse_x = engine.GetMouseX();
int mouse_y = engine.GetMouseY();
int origin_x = get_x() + get_width() / 2;
int origin_y = get_y() + get_height() / 2;
switch(m_shape){
case VertexShape::CIRCLE:
return (origin_x - mouse_x) * (origin_x - mouse_x) +
(origin_y - mouse_y) * (origin_y - mouse_y)
<= (get_width() / 2) * (get_width() / 2) ;
break;
case VertexShape::RECTANGLE:
return Widget::is_mouse_over(engine);
case VertexShape::DIAMOND:
break;
}
return false;
}
// ImGui
void Vertex::main_menu(ModifiedPGE& engine) {
ImGui::SetNextWindowPos({get_mouse_pos().first,
get_mouse_pos().second});
ImGui::Begin("Options");
if(ImGui::Button("Modify Label")) {
set_gui_state("mainMenu", false);
set_gui_state("modifyLabel", true);
}
if(ImGui::Button("Modify VertexShape")) {
set_gui_state("mainMenu", false);
set_gui_state("modifyVertexShape", true);
}
if(ImGui::Button("Modify Depth")) {
set_gui_state("mainMenu", false);
set_gui_state("modifyDepth", true);
}
if(!ImGui::IsWindowFocused()) {
set_gui_state("mainMenu", false);
engine.set_flag("has_active_popup_menu", false);
}
ImGui::End();
}
void Vertex::modify_label(ModifiedPGE& engine) {
ImGui::SetNextWindowPos({get_mouse_pos().first,
get_mouse_pos().second});
ImGui::Begin("Label");
char buf[30];
strcpy(buf, get_label().c_str());
if(ImGui::InputText("UTF-8 input", buf, IM_ARRAYSIZE(buf),
ImGuiInputTextFlags_EnterReturnsTrue)
|| (!ImGui::IsWindowFocused())) {
set_gui_state("modifyLabel", false);
engine.set_flag("has_active_popup_menu", false);
} else {
set_label(buf);
}
ImGui::End();
}
void Vertex::modify_shape(ModifiedPGE& engine) {
ImGui::SetNextWindowPos({get_mouse_pos().first, get_mouse_pos().second});
ImGui::Begin("VertexShape");
const char* items[] = { "CIRCLE", "SQUARE" };
int item_current = static_cast<int>(get_shape());
if(ImGui::ListBox("listbox\n(single select)",
&item_current,
items,
IM_ARRAYSIZE(items),
4)) {
set_gui_state("modifyVertexShape", false);
engine.set_flag("has_active_popup_menu", false);
}
set_shape(static_cast<VertexShape>(item_current));
ImGui::End();
}
// Update/Draw order related
void Vertex::move_forward(ModifiedPGE& engine) const {
engine.move_forward(get_id(), "vertex");
}
void Vertex::move_backward(ModifiedPGE& engine) const {
engine.move_backward(get_id(), "vertex");
}
void Vertex::move_front(ModifiedPGE& engine) const {
engine.move_front(get_id(), "vertex");
}
void Vertex::move_back(ModifiedPGE& engine) const {
engine.move_back(get_id(), "vertex");
}
}
|
include xlibproc.inc
include Wintab.inc
PROC_TEMPLATE WTOpen, 4, Wintab, -, 21
|
#ifndef CONTEXT_SEAL_CKKS_HPP
#define CONTEXT_SEAL_CKKS_HPP
#include <seal/seal.h>
#include <cmath>
#include <complex>
#include <sstream>
#include <type_traits>
#include "bits.hpp"
#include "circuit.hpp"
#include "context.hpp"
namespace SHEEP {
// default plaintext template inheriting from Context, in case
// someone tries to use a bool or integer input type, which is not supported.
template <typename PlaintextT>
class ContextSealCKKS : public Context<PlaintextT, seal::Ciphertext> {
public:
typedef seal::Ciphertext Ciphertext;
typedef PlaintextT Plaintext;
// constructor
ContextSealCKKS() {
throw InputTypeNotSupported();
}
Ciphertext encrypt(std::vector<Plaintext> pt) {
throw InputTypeNotSupported();
}
std::vector<Plaintext> decrypt(Ciphertext ct) {
throw InputTypeNotSupported();
}
};
// specialization for double
template <>
class ContextSealCKKS<double> : public Context<double, seal::Ciphertext> {
public:
typedef double Plaintext;
typedef seal::Ciphertext Ciphertext;
// constructors
ContextSealCKKS(
long plaintext_modulus =
40961, // for slots, this should be a prime congruent to 1 (mod 2N)
long N = 8192,
long scale_bits = 30 )
: m_N(N), m_scale_bits(scale_bits) {
this->m_param_name_map.insert({"N", m_N});
this->m_param_name_map.insert({"Scale_bits", m_scale_bits});
this->m_private_key_size = 0;
this->m_public_key_size = 0;
this->m_ciphertext_size = 0;
configure();
}
void configure() {
std::stringstream x;
x << "1x^" << m_N << " + 1";
this->m_poly_modulus = x.str();
seal::EncryptionParameters parms(seal::scheme_type::ckks);
parms.set_poly_modulus_degree(m_N);
this->m_scale = pow(2.0, m_scale_bits);
parms.set_coeff_modulus(seal::CoeffModulus::Create(m_N, { 40, 40, 40, 40, 40 }));
m_context = make_shared<seal::SEALContext>(parms);
seal::KeyGenerator keygen(*m_context);
m_secret_key = keygen.secret_key();
keygen.create_public_key(m_public_key);
keygen.create_galois_keys(m_galois_keys);
keygen.create_relin_keys(m_relin_keys);
m_encoder = new seal::CKKSEncoder(*m_context);
//// sizes of objects, in bytes
this->m_public_key_size = sizeof(m_public_key);
this->m_private_key_size = sizeof(m_secret_key);
m_encryptor = new seal::Encryptor(*m_context, m_public_key);
m_evaluator = new seal::Evaluator(*m_context);
m_decryptor = new seal::Decryptor(*m_context, m_secret_key);
this->m_nslots = m_encoder->slot_count();
}
Ciphertext encrypt(std::vector<Plaintext> p) {
if (this->get_num_slots() < p.size()) {
throw std::runtime_error(
"ContextSealCKKS::encrypt: The number of input data elements exceeds the "
"number of slots provided by the context.");
}
std::vector<Plaintext> p_all(this->get_num_slots(), (Plaintext)0.);
// We can assume p.size() < number of slots due to check above
for (size_t i = 0; i < this->m_nslots; i++) p_all[i] = p[i % p.size()];
seal::Plaintext pt;
m_encoder->encode(p_all, m_scale, pt);
seal::Ciphertext ct;
m_encryptor->encrypt(pt, ct);
this->m_ciphertext_size = sizeof(ct);
return ct;
}
std::vector<Plaintext> decrypt(Ciphertext ct) {
seal::Plaintext pt;
m_decryptor->decrypt(ct, pt);
std::vector<Plaintext> output(this->get_num_slots());
m_encoder->decode(pt, output);
std::vector<Plaintext> p(this->get_num_slots());
for (size_t i = 0; i < this->get_num_slots(); i++) p[i] = output[i];
return p;
}
std::string encrypt_and_serialize(std::vector<Plaintext> pt) {
Ciphertext ct = encrypt(pt);
std::stringstream ss;
ct.save(ss);
std::string ctstring = ss.str();
return ctstring;
};
Ciphertext Add(Ciphertext a, Ciphertext b) {
m_evaluator->add_inplace(a, b);
return a;
}
Ciphertext Multiply(Ciphertext a, Ciphertext b) {
m_evaluator->multiply_inplace(a, b);
/// relinearize
m_evaluator->relinearize_inplace(a, m_relin_keys);
return a;
}
Ciphertext Subtract(Ciphertext a, Ciphertext b) {
m_evaluator->sub_inplace(a, b);
return a;
}
Ciphertext Rotate(Ciphertext a, long n) {
Ciphertext b, c;
long N = this->get_num_slots();
if (n > 0) n = n - this->m_ninputs;
// SEAL won't accept values for the step count outside [-N/2, N/2]
int step_count = (-n) % (N / 2);
m_evaluator->rotate_rows(a, step_count, m_galois_keys, b);
return b;
}
// destructor
virtual ~ContextSealCKKS() {
/// delete everything we new-ed in the constructor
// if (m_context != NULL) delete m_context;
if (m_encoder != NULL) delete m_encoder;
if (m_encryptor != NULL) delete m_encryptor;
if (m_evaluator != NULL) delete m_evaluator;
if (m_decryptor != NULL) delete m_decryptor;
};
protected:
std::string m_poly_modulus;
long m_N;
long m_scale_bits;
double m_scale;
std::shared_ptr<seal::SEALContext> m_context;
seal::CKKSEncoder* m_encoder;
seal::PublicKey m_public_key;
seal::SecretKey m_secret_key;
seal::GaloisKeys m_galois_keys;
seal::RelinKeys m_relin_keys;
seal::Encryptor* m_encryptor;
seal::Evaluator* m_evaluator;
seal::Decryptor* m_decryptor;
};
// specialization for complex<double>
template <>
class ContextSealCKKS<std::complex<double> >: public Context<std::complex<double>, seal::Ciphertext> {
public:
typedef std::complex<double> Plaintext;
typedef seal::Ciphertext Ciphertext;
// constructors
ContextSealCKKS(
long plaintext_modulus =
40961, // for slots, this should be a prime congruent to 1 (mod 2N)
long N = 8192,
long scale_bits = 30 )
: m_N(N), m_scale_bits(scale_bits) {
this->m_param_name_map.insert({"N", m_N});
this->m_param_name_map.insert({"Scale_bits", m_scale_bits});
this->m_private_key_size = 0;
this->m_public_key_size = 0;
this->m_ciphertext_size = 0;
configure();
}
void configure() {
std::stringstream x;
x << "1x^" << m_N << " + 1";
this->m_poly_modulus = x.str();
seal::EncryptionParameters parms(seal::scheme_type::ckks);
parms.set_poly_modulus_degree(m_N);
this->m_scale = pow(2.0, m_scale_bits);
parms.set_coeff_modulus(seal::CoeffModulus::Create(m_N, { 40, 40, 40, 40, 40 }));
m_context = make_shared<seal::SEALContext>(parms);
seal::KeyGenerator keygen(*m_context);
m_secret_key = keygen.secret_key();
keygen.create_public_key(m_public_key);
keygen.create_galois_keys(m_galois_keys);
keygen.create_relin_keys(m_relin_keys);
m_encoder = new seal::CKKSEncoder(*m_context);
//// sizes of objects, in bytes
this->m_public_key_size = sizeof(m_public_key);
this->m_private_key_size = sizeof(m_secret_key);
m_encryptor = new seal::Encryptor(*m_context, m_public_key);
m_evaluator = new seal::Evaluator(*m_context);
m_decryptor = new seal::Decryptor(*m_context, m_secret_key);
this->m_nslots = m_encoder->slot_count();
}
Ciphertext encrypt(std::vector<Plaintext> p) {
if (this->get_num_slots() < p.size()) {
throw std::runtime_error(
"ContextSealCKKS::encrypt: The number of input data elements exceeds the "
"number of slots provided by the context.");
}
std::vector<Plaintext> p_all(this->get_num_slots(), (Plaintext)0.);
// We can assume p.size() < number of slots due to check above
for (size_t i = 0; i < this->m_nslots; i++) p_all[i] = p[i % p.size()];
seal::Plaintext pt;
m_encoder->encode(p_all, m_scale, pt);
seal::Ciphertext ct;
m_encryptor->encrypt(pt, ct);
this->m_ciphertext_size = sizeof(ct);
return ct;
}
std::vector<Plaintext> decrypt(Ciphertext ct) {
seal::Plaintext pt;
m_decryptor->decrypt(ct, pt);
std::vector<Plaintext> output(this->get_num_slots());
m_encoder->decode(pt, output);
std::vector<Plaintext> p(this->get_num_slots());
for (size_t i = 0; i < this->get_num_slots(); i++) p[i] = output[i];
return p;
}
std::string encrypt_and_serialize(std::vector<Plaintext> pt) {
Ciphertext ct = encrypt(pt);
std::stringstream ss;
ct.save(ss);
std::string ctstring = ss.str();
return ctstring;
};
Ciphertext Add(Ciphertext a, Ciphertext b) {
m_evaluator->add_inplace(a, b);
return a;
}
Ciphertext Multiply(Ciphertext a, Ciphertext b) {
m_evaluator->multiply_inplace(a, b);
/// relinearize
m_evaluator->relinearize_inplace(a, m_relin_keys);
return a;
}
Ciphertext Subtract(Ciphertext a, Ciphertext b) {
m_evaluator->sub_inplace(a, b);
return a;
}
Ciphertext Rotate(Ciphertext a, long n) override {
Ciphertext b, c;
long N = this->get_num_slots();
if (n > 0) n = n - this->m_ninputs;
// SEAL won't accept values for the step count outside [-N/2, N/2]
int step_count = (-n) % (N / 2);
m_evaluator->rotate_rows(a, step_count, m_galois_keys, b);
return b;
}
// destructor
~ContextSealCKKS() override {
/// delete everything we new-ed in the constructor
// if (m_context != NULL) delete m_context;
delete m_encoder;
delete m_encryptor;
delete m_evaluator;
delete m_decryptor;
};
protected:
std::string m_poly_modulus;
long m_N;
long m_scale_bits;
double m_scale;
std::shared_ptr<seal::SEALContext> m_context;
seal::CKKSEncoder* m_encoder;
seal::PublicKey m_public_key;
seal::SecretKey m_secret_key;
seal::GaloisKeys m_galois_keys;
seal::RelinKeys m_relin_keys;
seal::Encryptor* m_encryptor;
seal::Evaluator* m_evaluator;
seal::Decryptor* m_decryptor;
};
} // namespace SHEEP
#endif // CONTEXT_SEAL_CKKS_HPP
|
/*================================================================================
code generated by: java2cpp
author: Zoran Angelov, mailto://baldzar@gmail.com
class: android.text.style.WrapTogetherSpan
================================================================================*/
#ifndef J2CPP_INCLUDE_IMPLEMENTATION
#ifndef J2CPP_ANDROID_TEXT_STYLE_WRAPTOGETHERSPAN_HPP_DECL
#define J2CPP_ANDROID_TEXT_STYLE_WRAPTOGETHERSPAN_HPP_DECL
namespace j2cpp { namespace java { namespace lang { class Object; } } }
namespace j2cpp { namespace android { namespace text { namespace style { class ParagraphStyle; } } } }
#include <android/text/style/ParagraphStyle.hpp>
#include <java/lang/Object.hpp>
namespace j2cpp {
namespace android { namespace text { namespace style {
class WrapTogetherSpan;
class WrapTogetherSpan
: public object<WrapTogetherSpan>
{
public:
J2CPP_DECLARE_CLASS
explicit WrapTogetherSpan(jobject jobj)
: object<WrapTogetherSpan>(jobj)
{
}
operator local_ref<java::lang::Object>() const;
operator local_ref<android::text::style::ParagraphStyle>() const;
}; //class WrapTogetherSpan
} //namespace style
} //namespace text
} //namespace android
} //namespace j2cpp
#endif //J2CPP_ANDROID_TEXT_STYLE_WRAPTOGETHERSPAN_HPP_DECL
#else //J2CPP_INCLUDE_IMPLEMENTATION
#ifndef J2CPP_ANDROID_TEXT_STYLE_WRAPTOGETHERSPAN_HPP_IMPL
#define J2CPP_ANDROID_TEXT_STYLE_WRAPTOGETHERSPAN_HPP_IMPL
namespace j2cpp {
android::text::style::WrapTogetherSpan::operator local_ref<java::lang::Object>() const
{
return local_ref<java::lang::Object>(get_jobject());
}
android::text::style::WrapTogetherSpan::operator local_ref<android::text::style::ParagraphStyle>() const
{
return local_ref<android::text::style::ParagraphStyle>(get_jobject());
}
J2CPP_DEFINE_CLASS(android::text::style::WrapTogetherSpan,"android/text/style/WrapTogetherSpan")
} //namespace j2cpp
#endif //J2CPP_ANDROID_TEXT_STYLE_WRAPTOGETHERSPAN_HPP_IMPL
#endif //J2CPP_INCLUDE_IMPLEMENTATION
|
;
; Plotting in Timex/ZX modes
;
SECTION code_graphics
PUBLIC xor_MODE0
xor_MODE0:
defc NEEDxor = 1
INCLUDE "pixel_MODE0.inc"
|
; A198017: a(n) = n*(7*n + 11)/2 + 1.
; 1,10,26,49,79,116,160,211,269,334,406,485,571,664,764,871,985,1106,1234,1369,1511,1660,1816,1979,2149,2326,2510,2701,2899,3104,3316,3535,3761,3994,4234,4481,4735,4996,5264,5539,5821,6110,6406,6709,7019,7336,7660,7991,8329,8674,9026,9385,9751,10124,10504,10891,11285,11686,12094,12509,12931,13360,13796,14239,14689,15146,15610,16081,16559,17044,17536,18035,18541,19054,19574,20101,20635,21176,21724,22279,22841,23410,23986,24569,25159,25756,26360,26971,27589,28214,28846,29485,30131,30784,31444,32111
mov $1,7
mul $1,$0
add $1,11
mul $1,$0
div $1,2
add $1,1
mov $0,$1
|
map_header SilphCo10F, SILPH_CO_10F, FACILITY, 0
end_map_header
|
; --COPYRIGHT--,BSD_EX
; Copyright (c) 2012, Texas Instruments Incorporated
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
;
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
;
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the distribution.
;
; * Neither the name of Texas Instruments Incorporated nor the names of
; its contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
; THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
; PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
; EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
; OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
; EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;
; ******************************************************************************
;
; MSP430 CODE EXAMPLE DISCLAIMER
;
; MSP430 code examples are self-contained low-level programs that typically
; demonstrate a single peripheral function or device feature in a highly
; concise manner. For this the code may rely on the device's power-on default
; register values and settings such as the clock configuration and care must
; be taken when combining code from several examples to avoid potential side
; effects. Also see www.ti.com/grace for a GUI- and www.ti.com/msp430ware
; for an API functional library-approach to peripheral configuration.
;
; --/COPYRIGHT--
;******************************************************************************
; MSP430F54xA Demo - Software Toggle P1.0 with 12MHz DCO
;
; Description: Toggle P1.0 by xor'ing P1.0 inside of a software loop.
; ACLK is rought out on pin P11.0, SMCLK is brought out on P11.2, and MCLK
; is brought out on pin P11.1.
; ACLK = REFO = 32kHz, MCLK = SMCLK = 12MHz
; PMMCOREV = 1 to support up to 12MHz clock
;
; MSP430F5438A
; -----------------
; /|\| |
; | | P11.0|-->ACLK
; --|RST P11.1|-->MCLK
; | P11.2|-->SMCLK
; | |
; | P1.0|-->LED
;
; Note:
; In order to run the system at up to 12MHz, VCore must be set at 1.6V
; or higher. This is done by invoking function SetVCore().
;
; F. Chen
; Texas Instruments Inc.
; December 2012
; Built with CCS Version: 5.2.1
;******************************************************************************
.cdecls C,LIST,"msp430.h"
;-------------------------------------------------------------------------------
.def RESET ; Export program entry-point to
; make it known to linker.
;-------------------------------------------------------------------------------
.global _main
.text ; Assemble to Flash memory
;-------------------------------------------------------------------------------
_main
RESET mov.w #0x5C00,SP ; Initialize stackpointer
mov.w #WDTPW+WDTHOLD,&WDTCTL ; Stop WDT
mov.w #PMMCOREV_1, R12 ; Set VCore to 1.6V to support 12MHz clock
calla #SetVCore
bis.b #BIT0,&P1DIR ; P1.0 output
bis.b #0x07,&P11DIR ; ACLK, MCLK, SMCLK set out to pins
bis.b #0x07,&P11SEL ; P11.0, 1, 2 for debugging purposes
; Initialize clocks
bis.w #SELREF_2,&UCSCTL3 ; Set DCO FLL reference = REFO
bis.w #SELA_2,&UCSCTL4 ; Set ACLK = REFO
bis.w #SCG0,SR ; Disable the FLL control loop
clr.w &UCSCTL0 ; Set lowest possible DCOx, MODx
mov.w #DCORSEL_5,&UCSCTL1 ; Select range for 24 MHz operation
mov.w #FLLD_1 + 366,&UCSCTL2 ; Set DCO multiplier for 12 MHz
; (N + 1) * FLLRef = Fdco
; (366 + 1) * 32768 = 12MHz
; Set FLL Div = fDCOCLK/2
bic.w #SCG0,SR ; Enable the FLL control loop
; Worst-case settling time for the DCO when the DCO range bits have been
; changed is n x 32 x 32 x f_FLL_reference. See UCS chapter in 5xx UG
; for optimization.
; 32 x 32 x 12 MHz / 32,768 Hz = 375000 = MCLK cycles for DCO to settle
mov.w #0x6E34,R15
nop
mov.w #0x1,R14
delay_L1 add.w #0xFFFF,R15
addc.w #0xFFFF,R14
jc delay_L1
; Loop until XT1,XT2 & DCO fault flag is cleared
do_while bic.w #XT2OFFG + XT1LFOFFG + XT1HFOFFG + DCOFFG,&UCSCTL7
; Clear XT2,XT1,DCO fault flags
bic.w #OFIFG,&SFRIFG1 ; Clear fault flags
bit.w #OFIFG,&SFRIFG1 ; Test oscillator fault flag
jc do_while
while_loop xor.b #BIT0,&P1OUT ; Flash the LED
mov.w #0xFFFF,R4 ; Initialize loop counter R4=65535
delay_loop dec.w R4 ; Decrement loop counter
jne delay_loop ; Loop if loop counter > 0
jmp while_loop ; Infinite while loop
;-------------------------------------------------------------------------------
SetVCore ; SetVCore function
; In order to support high speed MCLK , The voltage level of Vcore must be sufficiently high
; The voltage level of Vcore must be increased by one step one time
;-------------------------------------------------------------------------------
mov.b #PMMPW_H, &PMMCTL0_H ;Open PMM registers for write
; Set SVS/SVM high side new level
mov.w R12,R15 ; R12--->R15
and.w #0xff,R15
swpb R15 ;exchange the high and low byte of R15
add.w R12,R15 ;add src to dst src+dst--->dst
add.w #0x4400,R15 ;SVM high-side enable ,SVS high-side enable
mov.w R15,&SVSMHCTL ;
; Set SVM low side to new level
mov.w R12,R15
add.w #0x4400,R15
mov.w R15,&SVSMLCTL
; Wait till SVM is settled
do_while1 bit.w #SVSMLDLYIFG,&PMMIFG ; Test SVSMLDLYIFG
jz do_while1
; Clear already set flags
bic.w #SVMLIFG,&PMMIFG ;clear SVM low-side interrupt flag
bic.w #SVMLVLRIFG,&PMMIFG ;clear SVM low-side voltage level reached interrupt flag
; Set VCore to new level
mov.b R12,&PMMCTL0_L
; Wait till new level reached
bit.w #SVMLIFG,&PMMIFG
jz low_set
do_while2 bit.w #SVMLVLRIFG,&PMMIFG ; Test SVMLvLrIFG
jz do_while2
;Set SVS/SVM low side to new level
low_set mov.w R12,R15
and.w #0xff,R15
swpb R15
add.w R15,R12
add.w #0x4400,R12
mov.w R12,&SVSMLCTL
;Lock PMM registers for write access
clr.b &PMMCTL0_H
RETA
;-------------------------------------------------------------------------------
; Interrupt Vectors
;-------------------------------------------------------------------------------
.sect ".reset" ; POR, ext. Reset
.short RESET
.end
|
; A176281: Hankel transform of A176280.
; 1,3,12,56,280,1440,7488,39104,204544,1070592,5604864,29345792,153653248,804532224,4212572160,22057287680,115493404672,604731211776,3166413520896,16579556016128,86811681488896,454551863820288,2380064454868992,12462179269738496,65252817790566400,341668189647667200,1788997866690183168,9367314441483321344,49047895182004977664,256818113325828145152,1344717099226412089344,7041030142054086213632,36867312455416721440768,193039754164279688822784,1010769275164002657239040,5292456634326880008273920
add $0,1
lpb $0
mul $1,2
add $1,1
mov $2,$0
sub $0,1
seq $2,1906 ; F(2n) = bisection of Fibonacci sequence: a(n) = 3*a(n-1) - a(n-2).
add $1,$2
lpe
div $1,4
add $1,1
mov $0,$1
|
; A089068: a(n) = a(n-1)+a(n-2)+a(n-3)+2 with a(0)=0, a(1)=0 and a(2)=1.
; 0,0,1,3,6,12,23,43,80,148,273,503,926,1704,3135,5767,10608,19512,35889,66011,121414,223316,410743,755475,1389536,2555756,4700769,8646063,15902590,29249424,53798079,98950095,181997600,334745776,615693473
sub $0,1
cal $0,301657 ; Number of nX3 0..1 arrays with every element equal to 0, 1 or 4 horizontally or vertically adjacent elements, with upper left element zero.
mov $1,$0
sub $1,3
|
; A182770: Beatty sequence for 3-sqrt(2).
; 1,3,4,6,7,9,11,12,14,15,17,19,20,22,23,25,26,28,30,31,33,34,36,38,39,41,42,44,45,47,49,50,52,53,55,57,58,60,61,63,65,66,68,69,71,72,74,76,77,79,80,82,84,85,87,88,90,91,93,95,96,98,99,101,103,104,106,107,109,111,112,114,115,117,118,120,122,123,125,126,128,130,131,133,134,136,137,139,141,142,144,145,147,149,150,152,153,155,156,158,160,161,163,164,166,168,169,171,172,174,176,177,179,180,182,183,185,187,188,190,191,193,195,196,198,199,201,202,204,206,207,209,210,212,214,215,217,218,220,222,223,225,226,228,229,231,233,234,236,237,239,241,242,244,245,247,248,250,252,253,255,256,258,260,261,263,264,266,267,269,271,272,274,275,277,279,280,282,283,285,287,288,290,291,293,294,296,298,299,301,302,304,306,307,309,310,312,313,315,317,318,320,321,323,325,326,328,329,331,333,334,336,337,339,340,342,344,345,347,348,350,352,353,355,356,358,359,361,363,364,366,367,369,371,372,374,375,377,379,380,382,383,385,386,388,390,391,393,394,396
add $0,1
cal $0,195176 ; a(n) = 3*n - floor(n*sqrt(2)).
mov $1,$0
sub $1,1
|
;------------------------------------------------------------------------------
;
; Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
; This program and the accompanying materials
; are licensed and made available under the terms and conditions of the BSD License
; which accompanies this distribution. The full text of the license may be found at
; http://opensource.org/licenses/bsd-license.php.
;
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
; Module Name:
;
; ReadPmc.Asm
;
; Abstract:
;
; AsmReadPmc function
;
; Notes:
;
;------------------------------------------------------------------------------
SECTION .text
;------------------------------------------------------------------------------
; UINT64
; EFIAPI
; AsmReadPmc (
; IN UINT32 PmcIndex
; );
;------------------------------------------------------------------------------
global ASM_PFX(AsmReadPmc)
ASM_PFX(AsmReadPmc):
mov ecx, [esp + 4]
rdpmc
ret
|
; A186150: Rank of (1/4)n^3 when {(1/4)i^3: i>=1} and {j^2>: j>=1} are jointly ranked with (1/4)i^3 after j^2 when (1/4)i^3=j^2. Complement of A186151.
; 1,3,5,8,10,13,16,19,22,25,29,32,36,40,44,48,52,56,60,64,69,73,78,82,87,92,97,102,107,112,117,122,127,133,138,144,149,155,160,166,172,178,183,189,195,201,208,214,220,226,233,239,245,252,258,265,272,278,285,292,299,306,313,320,327,334,341,348,355,362,370,377,384,392,399,407,414,422,430,437,445,453,461,468,476,484,492,500,508,516,525,533,541,549,557,566,574,583,591,600
mov $2,$0
add $2,1
mov $3,$0
lpb $2
mov $0,$3
sub $2,1
sub $0,$2
mov $5,$0
mov $7,2
lpb $7
mov $0,$5
sub $7,1
add $0,$7
cal $0,93 ; a(n) = floor(n^(3/2)).
div $0,2
mul $0,2
mov $4,$0
mov $8,$7
lpb $8
mov $6,$4
sub $8,1
lpe
lpe
lpb $5
mov $5,0
sub $6,$4
lpe
mov $4,$6
div $4,2
add $4,1
add $1,$4
lpe
|
kp_song
kp_reloc
dc.w kp_song_registers
dc.w kp_speed
dc.w kp_grooveboxpos
dc.w kp_grooveboxlen
dc.w kp_groovebox
dc.w kp_patternlen
dc.w kp_patternmap_lo
dc.w kp_patternmap_hi
dc.w kp_insmap_lo
dc.w kp_insmap_hi
dc.w kp_volmap_lo
dc.w kp_volmap_hi
dc.w kp_sequence
kp_song_registers
kp_speed
dc.b $02
kp_grooveboxpos
dc.b $00
kp_grooveboxlen
dc.b $04
kp_groovebox
dc.b $04
dc.b $03
dc.b $05
dc.b $03
dc.b $05
dc.b $04
dc.b $06
dc.b $04
kp_patternlen
dc.b $3F
kp_patternmap_lo
dc.b #<patnil
dc.b #<pat1
dc.b #<pat2
dc.b #<pat3
dc.b #<pat4
dc.b #<pat5
dc.b #<pat6
dc.b #<pat7
dc.b #<pat8
dc.b #<pat9
dc.b #<pat10
dc.b #<pat11
dc.b #<pat12
dc.b #<pat13
dc.b #<pat14
dc.b #<pat15
dc.b #<pat16
dc.b #<pat17
kp_patternmap_hi
dc.b #>patnil
dc.b #>pat1
dc.b #>pat2
dc.b #>pat3
dc.b #>pat4
dc.b #>pat5
dc.b #>pat6
dc.b #>pat7
dc.b #>pat8
dc.b #>pat9
dc.b #>pat10
dc.b #>pat11
dc.b #>pat12
dc.b #>pat13
dc.b #>pat14
dc.b #>pat15
dc.b #>pat16
dc.b #>pat17
patnil
kp_setinstrument 8,0
kp_settrackregister 0,16
kp_rewind $00
pat1
pat1loop
kp_settrackregister $01,$40
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $01,$38
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_rewind [pat1loop-pat1]
pat2
pat2loop
kp_settrackregister $01,$10
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $01,$A4
kp_settrackregister $03,$0A
kp_setinstrument $06,$03
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $01,$A4
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_setinstrument $06,$03
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $06,$03
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_rewind [pat2loop-pat2]
pat3
pat3loop
kp_settrackregister $01,$30
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $01,$38
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_rewind [pat3loop-pat3]
pat4
pat4loop
kp_settrackregister $01,$24
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $01,$A4
kp_settrackregister $03,$0A
kp_setinstrument $06,$03
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $01,$A4
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_setinstrument $06,$03
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $06,$03
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_rewind [pat4loop-pat4]
pat5
pat5loop
kp_settrackregister $01,$40
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $01,$44
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $06,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_rewind [pat5loop-pat5]
pat6
pat6loop
kp_settrackregister $01,$30
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $03,$0E
kp_setinstrument $02,$01
kp_settrackregister $03,$0C
kp_settrackregister $00,$02
kp_settrackregister $01,$38
kp_settrackregister $03,$0E
kp_setinstrument $20,$01
kp_settrackregister $00,$04
kp_rewind [pat6loop-pat6]
pat7
pat7loop
kp_settrackregister $01,$24
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $01,$A4
kp_settrackregister $03,$0A
kp_setinstrument $06,$03
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_setinstrument $04,$03
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $02,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$0A
kp_settrackregister $01,$90
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $01,$A4
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_settrackregister $03,$0A
kp_setinstrument $04,$03
kp_settrackregister $01,$90
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $01,$A4
kp_settrackregister $03,$06
kp_setinstrument $02,$03
kp_rewind [pat7loop-pat7]
pat8
pat8loop
kp_settrackregister $01,$10
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$40
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$10
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$40
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$38
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$38
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$1C
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_rewind [pat8loop-pat8]
pat9
pat9loop
kp_settrackregister $01,$24
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$54
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$24
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$54
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$38
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$38
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_rewind [pat9loop-pat9]
pat10
pat10loop
kp_settrackregister $01,$8C
kp_settrackregister $03,$0D
kp_setinstrument $04,$05
kp_settrackregister $01,$84
kp_settrackregister $00,$04
kp_settrackregister $01,$80
kp_settrackregister $00,$04
kp_settrackregister $01,$78
kp_settrackregister $00,$04
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$03
kp_settrackregister $01,$68
kp_settrackregister $03,$0D
kp_settrackregister $00,$04
kp_settrackregister $01,$70
kp_settrackregister $00,$0C
kp_settrackregister $03,$0A
kp_settrackregister $00,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$10
kp_settrackregister $01,$78
kp_settrackregister $03,$0D
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_rewind [pat10loop-pat10]
pat11
pat11loop
kp_settrackregister $01,$7C
kp_settrackregister $03,$0D
kp_setinstrument $05,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0D
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0D
kp_settrackregister $00,$04
kp_settrackregister $01,$78
kp_settrackregister $00,$04
kp_settrackregister $01,$70
kp_settrackregister $00,$04
kp_settrackregister $01,$78
kp_settrackregister $00,$08
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$02
kp_settrackregister $01,$70
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$06
kp_settrackregister $01,$68
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$06
kp_settrackregister $01,$78
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$02
kp_settrackregister $01,$70
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$02
kp_rewind [pat11loop-pat11]
pat12
pat12loop
kp_settrackregister $01,$8C
kp_settrackregister $03,$0D
kp_setinstrument $04,$05
kp_settrackregister $01,$84
kp_settrackregister $00,$04
kp_settrackregister $01,$80
kp_settrackregister $00,$04
kp_settrackregister $01,$8C
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$A0
kp_settrackregister $03,$0D
kp_settrackregister $00,$04
kp_settrackregister $01,$98
kp_settrackregister $00,$0C
kp_settrackregister $03,$0A
kp_settrackregister $00,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$10
kp_settrackregister $01,$A0
kp_settrackregister $03,$0D
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_rewind [pat12loop-pat12]
pat13
pat13loop
kp_settrackregister $01,$84
kp_settrackregister $03,$0D
kp_setinstrument $05,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$90
kp_settrackregister $03,$0D
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0D
kp_settrackregister $00,$04
kp_settrackregister $01,$8C
kp_settrackregister $00,$04
kp_settrackregister $01,$7C
kp_settrackregister $00,$04
kp_settrackregister $01,$68
kp_settrackregister $00,$08
kp_settrackregister $01,$78
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$02
kp_settrackregister $01,$70
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$06
kp_settrackregister $01,$68
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$06
kp_settrackregister $01,$78
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$02
kp_settrackregister $01,$70
kp_settrackregister $03,$0C
kp_setinstrument $02,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$02
kp_rewind [pat13loop-pat13]
pat14
pat14loop
kp_settrackregister $01,$24
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$54
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$24
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$54
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$08
kp_settrackregister $03,$0F
kp_setinstrument $03,$02
kp_settrackregister $03,$0E
kp_settrackregister $00,$01
kp_settrackregister $03,$0F
kp_setinstrument $04,$02
kp_settrackregister $01,$90
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$06
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$06
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0F
kp_setinstrument $02,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_rewind [pat14loop-pat14]
pat15
pat15loop
kp_settrackregister $01,$8C
kp_settrackregister $03,$0D
kp_setinstrument $04,$05
kp_settrackregister $01,$84
kp_settrackregister $00,$04
kp_settrackregister $01,$80
kp_settrackregister $00,$04
kp_settrackregister $01,$78
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$80
kp_settrackregister $03,$0D
kp_settrackregister $00,$04
kp_settrackregister $01,$70
kp_settrackregister $00,$0C
kp_settrackregister $03,$0A
kp_settrackregister $00,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$10
kp_settrackregister $01,$78
kp_settrackregister $03,$0D
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_rewind [pat15loop-pat15]
pat16
pat16loop
kp_settrackregister $01,$8C
kp_settrackregister $03,$0D
kp_setinstrument $09,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$A0
kp_settrackregister $03,$0D
kp_settrackregister $00,$09
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$98
kp_settrackregister $03,$0D
kp_settrackregister $00,$0C
kp_settrackregister $03,$0A
kp_settrackregister $00,$04
kp_settrackregister $03,$09
kp_settrackregister $00,$10
kp_settrackregister $01,$A0
kp_settrackregister $03,$0D
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_rewind [pat16loop-pat16]
pat17
pat17loop
kp_settrackregister $01,$84
kp_settrackregister $03,$0D
kp_setinstrument $05,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$90
kp_settrackregister $03,$0D
kp_settrackregister $00,$05
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $03,$0D
kp_settrackregister $00,$04
kp_settrackregister $01,$8C
kp_settrackregister $00,$04
kp_settrackregister $01,$84
kp_settrackregister $00,$04
kp_settrackregister $01,$98
kp_settrackregister $00,$0D
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$02
kp_settrackregister $01,$84
kp_settrackregister $03,$0D
kp_settrackregister $00,$0C
kp_settrackregister $01,$A0
kp_settrackregister $00,$06
kp_settrackregister $03,$0A
kp_settrackregister $00,$01
kp_settrackregister $03,$09
kp_settrackregister $00,$01
kp_rewind [pat17loop-pat17]
kp_insmap_lo
dc.b #<insnil
dc.b #<ins1
dc.b #<ins2
dc.b #<ins3
dc.b #<ins4
dc.b #<ins5
dc.b #<ins6
kp_insmap_hi
dc.b #>insnil
dc.b #>ins1
dc.b #>ins2
dc.b #>ins3
dc.b #>ins4
dc.b #>ins5
dc.b #>ins6
kp_volmap_lo
dc.b #<volnil
dc.b #<vol1
dc.b #<vol2
dc.b #<vol3
dc.b #<vol4
dc.b #<vol5
dc.b #<vol6
kp_volmap_hi
dc.b #>volnil
dc.b #>vol1
dc.b #>vol2
dc.b #>vol3
dc.b #>vol4
dc.b #>vol5
dc.b #>vol6
insnil
KP_OSCV 0,0,0,0,15
KP_OSCJ 0
volnil
KP_VOLV 0,15
KP_VOLJ 0
ins1
ins1loop
KP_OSCV $1C,0,1,1,$02
KP_OSCV $24,0,1,1,$02
KP_OSCV $30,0,1,1,$02
KP_OSCV $40,0,1,1,$02
KP_OSCJ [ins1loop-ins1]
vol1
KP_VOLV $0A,$01
KP_VOLV $08,$01
KP_VOLV $07,$01
KP_VOLV $06,$01
KP_VOLV $05,$01
vol1loop
KP_VOLV $04,$00
KP_VOLJ [vol1loop-vol1]
ins2
KP_OSCV $00,0,1,1,$05
ins2loop
KP_OSCV $00,0,1,1,$03
KP_OSCJ [ins2loop-ins2]
vol2
KP_VOLV $07,$02
KP_VOLV $06,$01
KP_VOLV $05,$00
vol2loop
KP_VOLV $02,$00
KP_VOLJ [vol2loop-vol2]
ins3
KP_OSCV $FC,1,0,1,$00
ins3loop
KP_OSCV $FB,1,0,1,$00
KP_OSCJ [ins3loop-ins3]
vol3
KP_VOLV $0C,$00
KP_VOLV $05,$00
vol3loop
KP_VOLV $00,$00
KP_VOLJ [vol3loop-vol3]
ins4
KP_OSCV $EF,1,0,1,$00
KP_OSCV $40,0,1,0,$00
KP_OSCV $30,0,1,0,$00
ins4loop
KP_OSCV $EE,1,0,1,$00
KP_OSCV $ED,1,0,1,$00
KP_OSCJ [ins4loop-ins4]
vol4
KP_VOLV $0F,$00
KP_VOLV $0C,$01
KP_VOLV $08,$00
KP_VOLV $04,$00
vol4loop
KP_VOLV $02,$00
KP_VOLJ [vol4loop-vol4]
ins5
KP_OSCV $24,0,1,1,$01
KP_OSCV $00,0,1,1,$00
ins5loop
KP_OSCV $00,0,1,1,$00
KP_OSCJ [ins5loop-ins5]
vol5
KP_VOLV $08,$00
vol5loop
KP_VOLV $07,$00
KP_VOLJ [vol5loop-vol5]
ins6
ins6loop
KP_OSCV $00,0,1,1,$01
KP_OSCV $30,0,1,1,$01
KP_OSCV $90,0,1,1,$01
KP_OSCJ [ins6loop-ins6]
vol6
KP_VOLV $0A,$01
KP_VOLV $08,$01
KP_VOLV $07,$01
vol6loop
KP_VOLV $06,$01
KP_VOLJ [vol6loop-vol6]
kp_sequence
dc.b $00,$01,$02,$00
dc.b $00,$03,$04,$00
dc.b $00,$05,$02,$00
dc.b $00,$06,$07,$00
dc.b $00,$01,$08,$00
dc.b $00,$03,$09,$00
dc.b $00,$05,$08,$00
dc.b $00,$06,$09,$00
dc.b $00,$0A,$08,$00
dc.b $00,$0B,$09,$00
dc.b $00,$0C,$08,$00
dc.b $00,$0D,$0E,$00
dc.b $00,$0F,$08,$00
dc.b $00,$0B,$09,$00
dc.b $00,$10,$08,$00
dc.b $00,$11,$09,$00
dc.b $ff
dc.w $0040
|
;===========================================================================
; Serial.asm
;---------------------------------------------------------------------------
; Assembly x86 library
;
;
; Author: Ahmed Hussein
; Created:
;
;
; This file provide procedures to communicate with another device
; through serial port
;
; Procedures included:
; * ConfigurePort
; * SendByte
; * CheckForData
; * RecieveByte
; * WaitForRecievedData
;===========================================================================
;-------------------- Definitions --------------------
DATA_READY EQU 00
DATA_NOT_READY EQU 01
LINE_STATUES_REGISTER EQU 03FDH
LINE_CONTROL_REGISTER EQU 03FBH
TRANSMIT_DATA_REGISTER EQU 03F8H
DIVISOR_LATCH_REGISTER EQU 03F9H
;-----------------------------------------------------
; CheckForData
;-----------------------------------------------------
; Check if there is a data recieved
; @return AL = DATA_READY or DATA_NOT_READY
;-----------------------------------------------------
CheckForData proc
PUSH DX
MOV DX, LINE_STATUES_REGISTER
IN AL, DX
TEST AL, DATA_NOT_READY
JZ @@ReturnNotReady
MOV AL, DATA_READY
JMP @@CheckForDataReturn
@@ReturnNotReady:
MOV AL, DATA_NOT_READY
@@CheckForDataReturn:
POP DX
RET
CheckForData endp
;-----------------------------------------------------
; RecieveByte
;-----------------------------------------------------
; @return AL = Character recieved
;-----------------------------------------------------
RecieveByte proc
PUSH DX
;Read the value
MOV DX, TRANSMIT_DATA_REGISTER
IN AL, DX
PUSH AX
;Reset Line Status Register flag
MOV AL, DATA_NOT_READY
MOV DX, LINE_STATUES_REGISTER
OUT DX,AL
POP AX
POP DX
RET
RecieveByte endp
;-----------------------------------------------------
; SendByte
;-----------------------------------------------------
; @param AL = Character to be sent
;-----------------------------------------------------
SendByte proc
PUSH DX
PUSH AX
;Check that Transimitter Holding Register is empty
MOV DX ,LINE_STATUES_REGISTER
@@CheckTHR:
IN AL,DX
AND AL, 00100000B
JZ @@CheckTHR
;Put the value in Transmit data register
POP AX
MOV DX, TRANSMIT_DATA_REGISTER
OUT DX, AL
POP DX
RET
SendByte endp
;-----------------------------------------------------
; ConfigurePort
;-----------------------------------------------------
; Configures the port for serial communication
;-----------------------------------------------------
ConfigurePort PROC
PUSH AX
PUSH DX
;Set divisor latch access bit
MOV DX,LINE_CONTROL_REGISTER
MOV AL,10000000B
OUT DX,AL
;Set LSB byte of the BaudRate Divisor latch register
MOV DX,TRANSMIT_DATA_REGISTER
MOV AL,0CH
OUT DX,AL
;Set MSB byte of the BaudRate Divisor latch register
MOV DX,DIVISOR_LATCH_REGISTER
MOV AL,00H
OUT DX,AL
;Set port configuration
MOV DX,LINE_CONTROL_REGISTER
MOV AL,00011011B
OUT DX,AL
POP DX
POP AX
RET
ConfigurePort ENDP
;-----------------------------------------------------
; WaitForRecievedData
;-----------------------------------------------------
; Wait untill there's data sent then read it
; @return AL = Character recieved
;-----------------------------------------------------
WaitForRecievedData PROC
PUSH DX
PUSH AX
;Check that Data Ready
MOV DX, LINE_STATUES_REGISTER
@@CheckForData:
IN AL,DX
AND AL, DATA_NOT_READY
JZ @@CheckForData
;Read the value recieved
POP AX
MOV DX, TRANSMIT_DATA_REGISTER
IN AL, DX
PUSH AX
;Reset Line Status Register flag
MOV AL, DATA_NOT_READY
MOV DX, LINE_STATUES_REGISTER
OUT DX,AL
POP AX
POP DX
RET
WaitForRecievedData ENDP |
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
#define CATCH_TAG_ALIAS_HPP_INCLUDED
#include <catch2/internal/catch_common.hpp>
#include <string>
namespace Catch {
struct TagAlias {
TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
tag(_tag),
lineInfo(_lineInfo)
{}
std::string tag;
SourceLineInfo lineInfo;
};
} // end namespace Catch
#endif // CATCH_TAG_ALIAS_HPP_INCLUDED
|
; A170650: Number of reduced words of length n in Coxeter group on 17 generators S_i with relations (S_i)^2 = (S_i S_j)^49 = I.
; 1,17,272,4352,69632,1114112,17825792,285212672,4563402752,73014444032,1168231104512,18691697672192,299067162755072,4785074604081152,76561193665298432,1224979098644774912,19599665578316398592
add $0,1
mov $3,1
lpb $0
sub $0,1
add $2,$3
div $3,$2
mul $2,16
lpe
mov $0,$2
div $0,16
|
; A022976: 20-n.
; 20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,-37,-38,-39,-40
sub $0,20
mul $0,-120259084286
mov $1,$0
div $1,120259084286
|
.size 8000
.text@48
jp lstatint
.text@100
jp lbegin
.data@143
c0
.text@150
lbegin:
ld a, 00
ldff(ff), a
ld b, 97
call lwaitly_b
ld a, b1
ldff(40), a
ld a, 07
ldff(4b), a
ld c, 41
ld a, 10
ldff(4a), a
ld a, 99
ldff(45), a
ld a, 40
ldff(c), a
xor a, a
ldff(0f), a
ld a, 02
ldff(ff), a
ei
.text@1000
lstatint:
nop
.text@10d4
ld a, 00
ldff(4a), a
.text@1118
ldff a, (c)
and a, 03
jp lprint_a
.text@7000
lprint_a:
push af
ld b, 91
call lwaitly_b
xor a, a
ldff(40), a
pop af
ld(9800), a
ld bc, 7a00
ld hl, 8000
ld d, a0
lprint_copytiles:
ld a, (bc)
inc bc
ld(hl++), a
dec d
jrnz lprint_copytiles
ld a, c0
ldff(47), a
ld a, 80
ldff(68), a
ld a, ff
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
xor a, a
ldff(69), a
ldff(69), a
ldff(43), a
ld a, 91
ldff(40), a
lprint_limbo:
jr lprint_limbo
.text@7400
lwaitly_b:
ld c, 44
lwaitly_b_loop:
ldff a, (c)
cmp a, b
jrnz lwaitly_b_loop
ret
.data@7a00
00 00 7f 7f 41 41 41 41
41 41 41 41 41 41 7f 7f
00 00 08 08 08 08 08 08
08 08 08 08 08 08 08 08
00 00 7f 7f 01 01 01 01
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 01 01 01 01
3f 3f 01 01 01 01 7f 7f
00 00 41 41 41 41 41 41
7f 7f 01 01 01 01 01 01
00 00 7f 7f 40 40 40 40
7e 7e 01 01 01 01 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 41 41 41 41 7f 7f
00 00 7f 7f 01 01 02 02
04 04 08 08 10 10 10 10
00 00 3e 3e 41 41 41 41
3e 3e 41 41 41 41 3e 3e
00 00 7f 7f 41 41 41 41
7f 7f 01 01 01 01 7f 7f
|
; A284396: Positions of 2 in A284394.
; 5,11,14,20,26,29,35,38,44,50,53,59,65,68,74,77,83,89,92,98,101,107,113,116,122,128,131,137,140,146,152,155,161,167,170,176,179,185,191,194,200,203,209,215,218,224,230,233,239,242,248,254,257,263,266,272,278,281,287,293,296,302,305,311,317,320,326,332,335,341,344,350,356,359,365,368,374,380,383,389,395,398,404,407,413,419,422,428,434,437,443,446,452,458,461,467,470,476,482,485,491,497,500,506,509,515,521,524,530,533,539,545,548,554,560,563,569,572,578,584,587,593,599,602,608,611,617,623,626,632,635,641,647,650,656,662,665,671,674,680,686,689,695,698,704,710,713,719,725,728,734,737,743,749,752,758,764,767,773,776,782,788,791,797,800,806,812,815,821,827,830,836,839,845,851,854,860,866,869,875,878,884,890,893,899,902,908,914,917,923,929,932,938,941,947,953,956,962,965,971,977,980,986,992,995,1001,1004,1010,1016,1019,1025,1031,1034,1040,1043,1049,1055,1058,1064,1067,1073,1079,1082,1088,1094,1097,1103,1106,1112,1118,1121,1127,1133,1136,1142,1145,1151,1157,1160,1166,1169,1175,1181,1184,1190,1196,1199,1205,1208,1214
mov $2,$0
add $2,1
mov $7,$0
lpb $2
mov $0,$7
sub $2,1
sub $0,$2
mov $3,$0
mov $5,2
lpb $5
mov $0,$3
sub $5,1
add $0,$5
mov $8,$0
pow $0,2
lpb $0
sub $0,$8
trn $0,1
add $8,2
lpe
mov $6,$5
mul $8,16
lpb $6
mov $4,$8
sub $6,1
lpe
lpe
lpb $3
mov $3,0
sub $4,$8
lpe
mov $8,$4
div $8,32
mul $8,3
add $8,3
add $1,$8
lpe
sub $1,6
div $1,3
mul $1,3
add $1,5
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r8
push %r9
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0xb081, %rbp
nop
nop
nop
nop
sub %r8, %r8
mov $0x6162636465666768, %r11
movq %r11, (%rbp)
nop
nop
nop
nop
nop
sub %rbx, %rbx
lea addresses_UC_ht+0x65c5, %rsi
lea addresses_A_ht+0x14285, %rdi
dec %r9
mov $37, %rcx
rep movsw
nop
nop
nop
nop
nop
add %rbx, %rbx
lea addresses_UC_ht+0x2dc5, %rsi
lea addresses_WT_ht+0x1d41d, %rdi
nop
nop
nop
nop
nop
and $26350, %rbx
mov $74, %rcx
rep movsl
nop
nop
sub $1978, %r11
lea addresses_UC_ht+0xb3c6, %r11
nop
nop
nop
nop
sub %r8, %r8
and $0xffffffffffffffc0, %r11
movaps (%r11), %xmm6
vpextrq $1, %xmm6, %rdi
nop
nop
nop
and %rcx, %rcx
lea addresses_UC_ht+0x1da5, %r9
nop
sub $37473, %rbp
movb $0x61, (%r9)
nop
nop
nop
nop
add %rcx, %rcx
lea addresses_WC_ht+0x12dfd, %rbp
nop
nop
nop
dec %rsi
mov $0x6162636465666768, %r11
movq %r11, %xmm1
vmovups %ymm1, (%rbp)
nop
nop
nop
nop
nop
cmp $46714, %r8
lea addresses_normal_ht+0x55c5, %rsi
add $15501, %rbp
movb (%rsi), %bl
nop
nop
sub $49374, %r8
lea addresses_normal_ht+0x3cc5, %rbx
nop
nop
nop
nop
add $49474, %r11
mov $0x6162636465666768, %r8
movq %r8, %xmm5
and $0xffffffffffffffc0, %rbx
vmovntdq %ymm5, (%rbx)
nop
nop
add $44004, %r8
lea addresses_WC_ht+0x7dc5, %rdi
and %rsi, %rsi
and $0xffffffffffffffc0, %rdi
movntdqa (%rdi), %xmm4
vpextrq $1, %xmm4, %r8
nop
nop
inc %r11
lea addresses_UC_ht+0x6fab, %rsi
nop
nop
nop
nop
nop
and %rcx, %rcx
mov (%rsi), %r9w
nop
nop
nop
nop
nop
and $56522, %r9
lea addresses_WT_ht+0xb8e5, %rsi
lea addresses_A_ht+0x8825, %rdi
and %rbx, %rbx
mov $90, %rcx
rep movsq
nop
nop
nop
nop
sub $13452, %r11
lea addresses_WT_ht+0x8705, %rsi
lea addresses_D_ht+0x114e5, %rdi
clflush (%rdi)
nop
nop
nop
and %rbx, %rbx
mov $87, %rcx
rep movsq
nop
nop
xor %rbp, %rbp
lea addresses_UC_ht+0x1737, %r9
nop
nop
nop
cmp %rsi, %rsi
movl $0x61626364, (%r9)
nop
inc %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r9
pop %r8
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r14
push %r15
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_D+0x9815, %r14
nop
nop
nop
lfence
movb $0x51, (%r14)
nop
nop
sub $58132, %rcx
// Store
lea addresses_WC+0xa9b7, %rsi
nop
nop
nop
nop
nop
and %rcx, %rcx
mov $0x5152535455565758, %r15
movq %r15, (%rsi)
// Exception!!!
mov (0), %rsi
nop
nop
nop
nop
dec %rdx
// Load
lea addresses_RW+0x192b5, %rsi
clflush (%rsi)
inc %r10
mov (%rsi), %r14
nop
xor %r10, %r10
// Faulty Load
lea addresses_normal+0x1d5c5, %rdi
clflush (%rdi)
nop
nop
xor $57188, %rsi
mov (%rdi), %rdx
lea oracles, %rsi
and $0xff, %rdx
shlq $12, %rdx
mov (%rsi,%rdx,1), %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r15
pop %r14
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_normal', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_D', 'AVXalign': False, 'size': 1}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 1, 'type': 'addresses_WC', 'AVXalign': False, 'size': 8}}
{'src': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_RW', 'AVXalign': False, 'size': 8}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_normal', 'AVXalign': False, 'size': 8}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 2, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 8}}
{'src': {'same': False, 'congruent': 9, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 6, 'type': 'addresses_A_ht'}}
{'src': {'same': False, 'congruent': 11, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 3, 'type': 'addresses_WT_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_UC_ht', 'AVXalign': True, 'size': 16}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 1}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 3, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 32}}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 1}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': True, 'same': False, 'congruent': 8, 'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 32}}
{'src': {'NT': True, 'same': False, 'congruent': 8, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 4, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 5, 'type': 'addresses_A_ht'}}
{'src': {'same': False, 'congruent': 5, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': True, 'congruent': 5, 'type': 'addresses_D_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 4}}
{'34': 1}
34
*/
|
; A208903: The sum over all bitstrings b of length n with at least two runs of the number of runs in b not immediately followed by a longer run.
; 0,4,12,32,76,180,412,940,2108,4700,10364,22716,49404,106876,229884,492284,1049596,2229756,4720636,9964540,20975612,44046332,92282876,192950268,402669564,838885372,1744863228,3623927804,7516258300,15569354748,32212385788,66572189692,137439215612,283468234748,584116076540,1202591629308,2473902211068,5085242851324,10445362561020,21440479887356,43980469305340,90159959769084,184717961854972,378232012537852,774056202731516,1583296769163260,3236962265726972,6614662003032060,13510798949220348,27584547818307580,56294995476348924,114841790699274236,234187180891701244,477381560903925756,972777520048898044,1981583836848324604,4035225267197706236,8214565721934397436,16717361818946764796,34011184389123211260,69175290280705785852,140656423568477782012,285924533151087984636,581072438334735777788,1180591620734591172604,2398076729608011513852,4869940435493681364988,9887454823559859273724,20070057552264711634940,40730410914853769183228,82641413450356230193148,167644010142078563516412,340010386766889333293052,689465506499380518060028,1397820478929964739067900,2833419889722611761938428,5742397643170588091482108,11635911013792455073988604,23574053482487467930025980,47752569874781150935777276,96714065569174732023005180,195845982777576523372167164,396527668833607165396647932,802726744224126966144434172,1624796301562079202991144956,3288278229351817743479865340,6653927711158954161954881532,13462597927228563266086109180,27234680864278436416524910588,55088331748199527786127294460,111414603535684365478409535484,225305087149939421137873141756,455561934457020222637854425084,921027389228323346737413488636,1861861819085212496398236254204,3763337719427556880118267772924,7605903601369377534880126074876,15370263527767283181997386629116,31057439705591622588469042216956,62748704711297358751786529193980
mov $2,$0
lpb $0
sub $0,1
mul $1,2
trn $2,2
add $1,$2
add $1,4
lpe
mov $0,$1
|
dnl SPARC v9 64-bit mpn_submul_1 -- Multiply a limb vector with a limb and
dnl subtract the result from a second limb vector.
dnl Copyright 2001-2003 Free Software Foundation, Inc.
dnl This file is part of the GNU MP Library.
dnl
dnl The GNU MP Library is free software; you can redistribute it and/or modify
dnl it under the terms of either:
dnl
dnl * the GNU Lesser General Public License as published by the Free
dnl Software Foundation; either version 3 of the License, or (at your
dnl option) any later version.
dnl
dnl or
dnl
dnl * the GNU General Public License as published by the Free Software
dnl Foundation; either version 2 of the License, or (at your option) any
dnl later version.
dnl
dnl or both in parallel, as here.
dnl
dnl The GNU MP Library is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
dnl or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
dnl for more details.
dnl
dnl You should have received copies of the GNU General Public License and the
dnl GNU Lesser General Public License along with the GNU MP Library. If not,
dnl see https://www.gnu.org/licenses/.
include(`../config.m4')
C cycles/limb
C UltraSPARC 1&2: 18
C UltraSPARC 3: 23
C INPUT PARAMETERS
C rp i0
C up i1
C n i2
C v i3
ASM_START()
REGISTER(%g2,#scratch)
PROLOGUE(mpn_submul_1)
save %sp,-176,%sp
sllx %i2, 3, %g2
or %g0, %i1, %o1
add %g2, 15, %o0
or %g0, %i2, %o2
and %o0, -16, %o0
sub %sp, %o0, %sp
add %sp, 2223, %o0
or %g0, %o0, %l0
call mpn_mul_1
or %g0, %i3, %o3
or %g0, %o0, %l1 C preserve carry value from mpn_mul_1
or %g0, %i0, %o0
or %g0, %i0, %o1
or %g0, %l0, %o2
call mpn_sub_n
or %g0, %i2, %o3
ret
restore %l1, %o0, %o0 C sum carry values
EPILOGUE(mpn_submul_1)
|
; A061397: Characteristic function sequence of primes multiplied componentwise by N, the natural numbers.
; Submitted by Jamie Morken(w3)
; 0,2,3,0,5,0,7,0,0,0,11,0,13,0,0,0,17,0,19,0,0,0,23,0,0,0,0,0,29,0,31,0,0,0,0,0,37,0,0,0,41,0,43,0,0,0,47,0,0,0,0,0,53,0,0,0,0,0,59,0,61,0,0,0,0,0,67,0,0,0,71,0,73,0,0,0,0,0,79,0,0,0,83,0,0,0,0,0,89,0,0,0,0,0,0,0,97,0,0,0
mov $2,$0
seq $2,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
add $0,$2
mul $0,$2
|
// ReDucTor is an awesome guy who helped me a lot
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "Server.h"
#include "ClientHandle.h"
#include "Mobs/Monster.h"
#include "Root.h"
#include "World.h"
#include "Bindings/PluginManager.h"
#include "ChatColor.h"
#include "Entities/Player.h"
#include "Inventory.h"
#include "Item.h"
#include "FurnaceRecipe.h"
#include "WebAdmin.h"
#include "Protocol/ProtocolRecognizer.h"
#include "CommandOutput.h"
#include "FastRandom.h"
#include "IniFile.h"
#include <fstream>
#include <sstream>
#include <iostream>
////////////////////////////////////////////////////////////////////////////////
// cServerListenCallbacks:
class cServerListenCallbacks:
public cNetwork::cListenCallbacks
{
cServer & m_Server;
UInt16 m_Port;
virtual cTCPLink::cCallbacksPtr OnIncomingConnection(const AString & a_RemoteIPAddress, UInt16 a_RemotePort) override
{
return m_Server.OnConnectionAccepted(a_RemoteIPAddress);
}
virtual void OnAccepted(cTCPLink & a_Link) override {}
virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) override
{
LOGWARNING("Cannot listen on port %d: %d (%s).", m_Port, a_ErrorCode, a_ErrorMsg.c_str());
}
public:
cServerListenCallbacks(cServer & a_Server, UInt16 a_Port):
m_Server(a_Server),
m_Port(a_Port)
{
}
};
////////////////////////////////////////////////////////////////////////////////
// cServer::cTickThread:
cServer::cTickThread::cTickThread(cServer & a_Server) :
Super("Server Ticker"),
m_Server(a_Server)
{
}
void cServer::cTickThread::Execute(void)
{
auto LastTime = std::chrono::steady_clock::now();
static const auto msPerTick = std::chrono::milliseconds(50);
while (!m_ShouldTerminate)
{
auto NowTime = std::chrono::steady_clock::now();
auto msec = std::chrono::duration_cast<std::chrono::milliseconds>(NowTime - LastTime).count();
m_Server.Tick(static_cast<float>(msec));
auto TickTime = std::chrono::steady_clock::now() - NowTime;
if (TickTime < msPerTick)
{
// Stretch tick time until it's at least msPerTick
std::this_thread::sleep_for(msPerTick - TickTime);
}
LastTime = NowTime;
}
}
////////////////////////////////////////////////////////////////////////////////
// cServer:
cServer::cServer(void) :
m_PlayerCount(0),
m_ClientViewDistance(0),
m_bIsConnected(false),
m_RCONServer(*this),
m_MaxPlayers(0),
m_bIsHardcore(false),
m_TickThread(*this),
m_ShouldAuthenticate(false),
m_UpTime(0)
{
// Initialize the LuaStateTracker singleton before the app goes multithreaded:
cLuaStateTracker::GetStats();
}
void cServer::ClientMovedToWorld(const cClientHandle * a_Client)
{
cCSLock Lock(m_CSClients);
m_ClientsToRemove.push_back(const_cast<cClientHandle *>(a_Client));
}
void cServer::PlayerCreated()
{
m_PlayerCount++;
}
void cServer::PlayerDestroyed()
{
m_PlayerCount--;
}
bool cServer::InitServer(cSettingsRepositoryInterface & a_Settings, bool a_ShouldAuth)
{
m_Description = a_Settings.GetValueSet("Server", "Description", "Cuberite - in C++!");
m_ShutdownMessage = a_Settings.GetValueSet("Server", "ShutdownMessage", "Server shutdown");
m_MaxPlayers = static_cast<size_t>(a_Settings.GetValueSetI("Server", "MaxPlayers", 100));
m_bIsHardcore = a_Settings.GetValueSetB("Server", "HardcoreEnabled", false);
m_bAllowMultiLogin = a_Settings.GetValueSetB("Server", "AllowMultiLogin", false);
m_ResourcePackUrl = a_Settings.GetValueSet("Server", "ResourcePackUrl", "");
m_FaviconData = Base64Encode(cFile::ReadWholeFile(AString("favicon.png"))); // Will return empty string if file nonexistant; client doesn't mind
if (m_bIsConnected)
{
LOGERROR("ERROR: Trying to initialize server while server is already running!");
return false;
}
LOGINFO("Compatible clients: %s", MCS_CLIENT_VERSIONS);
LOGD("Compatible protocol versions %s", MCS_PROTOCOL_VERSIONS);
m_Ports = ReadUpgradeIniPorts(a_Settings, "Server", "Ports", "Port", "PortsIPv6", "25565");
m_RCONServer.Initialize(a_Settings);
m_bIsConnected = true;
m_ServerID = "-";
m_ShouldAuthenticate = a_ShouldAuth;
if (m_ShouldAuthenticate)
{
auto & rand = GetRandomProvider();
unsigned int r1 = rand.RandInt<unsigned int>(1000000000U, 0x7fffffffU);
unsigned int r2 = rand.RandInt<unsigned int>(1000000000U, 0x7fffffffU);
std::ostringstream sid;
sid << std::hex << r1;
sid << std::hex << r2;
m_ServerID = sid.str();
m_ServerID.resize(16, '0');
}
// Check if both BungeeCord and online mode are on, if so, warn the admin:
m_ShouldAllowBungeeCord = a_Settings.GetValueSetB("Authentication", "AllowBungeeCord", false);
m_OnlyAllowBungeeCord = a_Settings.GetValueSetB("Authentication", "OnlyAllowBungeeCord", false);
m_ProxySharedSecret = a_Settings.GetValueSet("Authentication", "ProxySharedSecret", "");
if (m_ShouldAllowBungeeCord && m_ShouldAuthenticate)
{
LOGWARNING("WARNING: BungeeCord is allowed and server set to online mode. This is unsafe and will not work properly. Disable either authentication or BungeeCord in settings.ini.");
}
if (m_ShouldAllowBungeeCord && m_ProxySharedSecret.empty())
{
LOGWARNING("WARNING: There is not a Proxy Forward Secret set up, and any proxy server can forward a player to this server unless closed from the internet.");
}
m_ShouldAllowMultiWorldTabCompletion = a_Settings.GetValueSetB("Server", "AllowMultiWorldTabCompletion", true);
m_ShouldLimitPlayerBlockChanges = a_Settings.GetValueSetB("AntiCheat", "LimitPlayerBlockChanges", true);
const auto ClientViewDistance = a_Settings.GetValueSetI("Server", "DefaultViewDistance", cClientHandle::DEFAULT_VIEW_DISTANCE);
if (ClientViewDistance < cClientHandle::MIN_VIEW_DISTANCE)
{
m_ClientViewDistance = cClientHandle::MIN_VIEW_DISTANCE;
LOGINFO("Setting default view distance to the minimum of %d", m_ClientViewDistance);
}
else if (ClientViewDistance > cClientHandle::MAX_VIEW_DISTANCE)
{
m_ClientViewDistance = cClientHandle::MAX_VIEW_DISTANCE;
LOGINFO("Setting default view distance to the maximum of %d", m_ClientViewDistance);
}
else
{
m_ClientViewDistance = ClientViewDistance;
}
PrepareKeys();
return true;
}
bool cServer::RegisterForgeMod(const AString & a_ModName, const AString & a_ModVersion, UInt32 a_ProtocolVersionNumber)
{
auto & Mods = RegisteredForgeMods(a_ProtocolVersionNumber);
return Mods.insert({a_ModName, a_ModVersion}).second;
}
void cServer::UnregisterForgeMod(const AString & a_ModName, UInt32 a_ProtocolVersionNumber)
{
auto & Mods = RegisteredForgeMods(a_ProtocolVersionNumber);
auto it = Mods.find(a_ModName);
if (it != Mods.end())
{
Mods.erase(it);
}
}
AStringMap & cServer::RegisteredForgeMods(const UInt32 a_Protocol)
{
auto it = m_ForgeModsByVersion.find(a_Protocol);
if (it == m_ForgeModsByVersion.end())
{
AStringMap mods;
m_ForgeModsByVersion.insert({a_Protocol, mods});
return m_ForgeModsByVersion.find(a_Protocol)->second;
}
return it->second;
}
const AStringMap & cServer::GetRegisteredForgeMods(const UInt32 a_Protocol)
{
return RegisteredForgeMods(a_Protocol);
}
bool cServer::IsPlayerInQueue(const AString & a_Username)
{
cCSLock Lock(m_CSClients);
for (const auto & client : m_Clients)
{
if ((client->GetUsername()).compare(a_Username) == 0)
{
return true;
}
}
return false;
}
void cServer::PrepareKeys(void)
{
LOGD("Generating protocol encryption keypair...");
VERIFY(m_PrivateKey.Generate(1024));
m_PublicKeyDER = m_PrivateKey.GetPubKeyDER();
}
cTCPLink::cCallbacksPtr cServer::OnConnectionAccepted(const AString & a_RemoteIPAddress)
{
LOGD("Client \"%s\" connected!", a_RemoteIPAddress.c_str());
cClientHandlePtr NewHandle = std::make_shared<cClientHandle>(a_RemoteIPAddress, m_ClientViewDistance);
cCSLock Lock(m_CSClients);
m_Clients.push_back(NewHandle);
return std::move(NewHandle);
}
void cServer::Tick(float a_Dt)
{
// Update server uptime
m_UpTime++;
// Send the tick to the plugins, as well as let the plugin manager reload, if asked to (issue #102):
cPluginManager::Get()->Tick(a_Dt);
// Process all the queued commands:
TickCommands();
// Tick all clients not yet assigned to a world:
TickClients(a_Dt);
// Process all queued tasks
TickQueuedTasks();
}
void cServer::TickClients(float a_Dt)
{
cClientHandlePtrs RemoveClients;
{
cCSLock Lock(m_CSClients);
// Remove clients that have moved to a world (the world will be ticking them from now on)
for (auto itr = m_ClientsToRemove.begin(), end = m_ClientsToRemove.end(); itr != end; ++itr)
{
for (auto itrC = m_Clients.begin(), endC = m_Clients.end(); itrC != endC; ++itrC)
{
if (itrC->get() == *itr)
{
m_Clients.erase(itrC);
break;
}
}
} // for itr - m_ClientsToRemove[]
m_ClientsToRemove.clear();
// Tick the remaining clients, take out those that have been destroyed into RemoveClients
for (auto itr = m_Clients.begin(); itr != m_Clients.end();)
{
auto & Client = *itr;
Client->ServerTick(a_Dt);
if (Client->IsDestroyed())
{
// Delete the client later, when CS is not held, to avoid deadlock: https://forum.cuberite.org/thread-374.html
RemoveClients.push_back(std::move(Client));
itr = m_Clients.erase(itr);
continue;
}
++itr;
} // for itr - m_Clients[]
}
// Delete the clients that have been destroyed
RemoveClients.clear();
}
bool cServer::Start(void)
{
for (const auto & port: m_Ports)
{
UInt16 PortNum;
if (!StringToInteger(port, PortNum))
{
LOGWARNING("Invalid port specified for server: \"%s\". Ignoring.", port.c_str());
continue;
}
auto Handle = cNetwork::Listen(PortNum, std::make_shared<cServerListenCallbacks>(*this, PortNum));
if (Handle->IsListening())
{
m_ServerHandles.push_back(Handle);
}
} // for port - Ports[]
if (m_ServerHandles.empty())
{
LOGERROR("Couldn't open any ports. Aborting the server");
return false;
}
m_TickThread.Start();
return true;
}
bool cServer::Command(cClientHandle & a_Client, AString & a_Cmd)
{
bool Res = cRoot::Get()->DoWithPlayerByUUID(
a_Client.GetUUID(),
[&](cPlayer & a_Player)
{
return cRoot::Get()->GetPluginManager()->CallHookChat(a_Player, a_Cmd);
}
);
return Res;
}
void cServer::QueueExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output)
{
// Put the command into a queue (Alleviates FS #363):
cCSLock Lock(m_CSPendingCommands);
m_PendingCommands.emplace_back(a_Cmd, &a_Output);
}
void cServer::ScheduleTask(cTickTime a_DelayTicks, std::function<void(cServer &)> a_Task)
{
const auto TargetTick = a_DelayTicks + m_UpTime;
// Insert the task into the list of scheduled tasks
{
cCSLock Lock(m_CSTasks);
m_Tasks.emplace_back(TargetTick, std::move(a_Task));
}
}
void cServer::ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output)
{
AStringVector split = StringSplit(a_Cmd, " ");
if (split.empty())
{
return;
}
// "stop" and "restart" are handled in cRoot::ExecuteConsoleCommand, our caller, due to its access to controlling variables
// "help" and "reload" are to be handled by Cuberite, so that they work no matter what
if (split[0] == "help")
{
PrintHelp(split, a_Output);
a_Output.Finished();
return;
}
else if (split[0] == "reload")
{
if (split.size() > 1)
{
cPluginManager::Get()->ReloadPlugin(split[1]);
a_Output.Out("Plugin reload scheduled");
}
else
{
cPluginManager::Get()->ReloadPlugins();
}
a_Output.Finished();
return;
}
else if (split[0] == "reloadplugins")
{
cPluginManager::Get()->ReloadPlugins();
a_Output.Out("Plugins reloaded");
a_Output.Finished();
return;
}
else if (split[0] == "reloadweb")
{
cRoot::Get()->GetWebAdmin()->Reload();
a_Output.Out("WebAdmin configuration reloaded");
a_Output.Finished();
return;
}
else if (split[0] == "load")
{
if (split.size() > 1)
{
cPluginManager::Get()->RefreshPluginList(); // Refresh the plugin list, so that if the plugin was added just now, it is loadable
a_Output.Out(cPluginManager::Get()->LoadPlugin(split[1]) ? "Plugin loaded" : "Error occurred loading plugin");
}
else
{
a_Output.Out("Usage: load <PluginFolder>");
}
a_Output.Finished();
return;
}
else if (split[0] == "unload")
{
if (split.size() > 1)
{
cPluginManager::Get()->UnloadPlugin(split[1]);
a_Output.Out("Plugin unload scheduled");
}
else
{
a_Output.Out("Usage: unload <PluginFolder>");
}
a_Output.Finished();
return;
}
if (split[0] == "destroyentities")
{
cRoot::Get()->ForEachWorld([](cWorld & a_World)
{
a_World.ForEachEntity([](cEntity & a_Entity)
{
if (!a_Entity.IsPlayer())
{
a_Entity.Destroy();
}
return false;
}
);
return false;
}
);
a_Output.Out("Destroyed all entities");
a_Output.Finished();
return;
}
// There is currently no way a plugin can do these (and probably won't ever be):
else if (split[0].compare("chunkstats") == 0)
{
cRoot::Get()->LogChunkStats(a_Output);
a_Output.Finished();
return;
}
else if (split[0].compare("luastats") == 0)
{
a_Output.Out(cLuaStateTracker::GetStats());
a_Output.Finished();
return;
}
else if (cPluginManager::Get()->ExecuteConsoleCommand(split, a_Output, a_Cmd))
{
a_Output.Finished();
return;
}
a_Output.Out("Unknown command, type 'help' for all commands.");
a_Output.Finished();
}
void cServer::PrintHelp(const AStringVector & a_Split, cCommandOutputCallback & a_Output)
{
UNUSED(a_Split);
typedef std::pair<AString, AString> AStringPair;
typedef std::vector<AStringPair> AStringPairs;
class cCallback :
public cPluginManager::cCommandEnumCallback
{
public:
cCallback(void) : m_MaxLen(0) {}
virtual bool Command(const AString & a_Command, const cPlugin * a_Plugin, const AString & a_Permission, const AString & a_HelpString) override
{
UNUSED(a_Plugin);
UNUSED(a_Permission);
if (!a_HelpString.empty())
{
m_Commands.push_back(AStringPair(a_Command, a_HelpString));
if (m_MaxLen < a_Command.length())
{
m_MaxLen = a_Command.length();
}
}
return false;
}
AStringPairs m_Commands;
size_t m_MaxLen;
} Callback;
cPluginManager::Get()->ForEachConsoleCommand(Callback);
std::sort(Callback.m_Commands.begin(), Callback.m_Commands.end());
for (AStringPairs::const_iterator itr = Callback.m_Commands.begin(), end = Callback.m_Commands.end(); itr != end; ++itr)
{
const AStringPair & cmd = *itr;
a_Output.Out(Printf("%-*s - %s\n", static_cast<int>(Callback.m_MaxLen), cmd.first.c_str(), cmd.second.c_str()));
} // for itr - Callback.m_Commands[]
}
void cServer::BindBuiltInConsoleCommands(void)
{
// Create an empty handler - the actual handling for the commands is performed before they are handed off to cPluginManager
class cEmptyHandler:
public cPluginManager::cCommandHandler
{
virtual bool ExecuteCommand(
const AStringVector & a_Split,
cPlayer * a_Player,
const AString & a_Command,
cCommandOutputCallback * a_Output = nullptr
) override
{
return false;
}
};
auto handler = std::make_shared<cEmptyHandler>();
// Register internal commands:
cPluginManager * PlgMgr = cPluginManager::Get();
PlgMgr->BindConsoleCommand("help", nullptr, handler, "Shows the available commands");
PlgMgr->BindConsoleCommand("reload", nullptr, handler, "Reloads all plugins");
PlgMgr->BindConsoleCommand("reloadweb", nullptr, handler, "Reloads the webadmin configuration");
PlgMgr->BindConsoleCommand("restart", nullptr, handler, "Restarts the server cleanly");
PlgMgr->BindConsoleCommand("stop", nullptr, handler, "Stops the server cleanly");
PlgMgr->BindConsoleCommand("chunkstats", nullptr, handler, "Displays detailed chunk memory statistics");
PlgMgr->BindConsoleCommand("load", nullptr, handler, "Adds and enables the specified plugin");
PlgMgr->BindConsoleCommand("unload", nullptr, handler, "Disables the specified plugin");
PlgMgr->BindConsoleCommand("destroyentities", nullptr, handler, "Destroys all entities in all worlds");
}
void cServer::Shutdown(void)
{
// Stop listening on all sockets:
for (const auto & srv: m_ServerHandles)
{
srv->Close();
}
m_ServerHandles.clear();
// Notify the tick thread and wait for it to terminate:
m_TickThread.Stop();
// Save all chunks in all worlds, wait for chunks to be sent to the ChunkStorage queue for each world:
cRoot::Get()->SaveAllChunksNow();
// Remove all clients:
cCSLock Lock(m_CSClients);
for (auto itr = m_Clients.begin(); itr != m_Clients.end(); ++itr)
{
(*itr)->Destroy();
}
m_Clients.clear();
}
void cServer::KickUser(int a_ClientID, const AString & a_Reason)
{
cCSLock Lock(m_CSClients);
for (auto itr = m_Clients.begin(); itr != m_Clients.end(); ++itr)
{
if ((*itr)->GetUniqueID() == a_ClientID)
{
(*itr)->Kick(a_Reason);
}
} // for itr - m_Clients[]
}
void cServer::AuthenticateUser(int a_ClientID, AString && a_Username, const cUUID & a_UUID, Json::Value && a_Properties)
{
cCSLock Lock(m_CSClients);
// Check max players condition within lock (expect server and authenticator thread to both call here)
if (GetNumPlayers() >= GetMaxPlayers())
{
KickUser(a_ClientID, "The server is currently full :(" "\n" "Try again later?");
return;
}
for (const auto & Client : m_Clients)
{
if (Client->GetUniqueID() == a_ClientID)
{
Client->Authenticate(std::move(a_Username), a_UUID, std::move(a_Properties));
return;
}
}
}
void cServer::TickCommands(void)
{
decltype(m_PendingCommands) PendingCommands;
{
cCSLock Lock(m_CSPendingCommands);
std::swap(PendingCommands, m_PendingCommands);
}
// Execute any pending commands:
for (const auto & Command : PendingCommands)
{
ExecuteConsoleCommand(Command.first, *Command.second);
}
}
void cServer::TickQueuedTasks(void)
{
// Move the tasks to be executed to a seperate vector to avoid deadlocks on
// accessing m_Tasks
decltype(m_Tasks) Tasks;
{
cCSLock Lock(m_CSTasks);
if (m_Tasks.empty())
{
return;
}
// Partition everything to be executed by returning false to move to end
// of list if time reached
auto MoveBeginIterator = std::partition(
m_Tasks.begin(), m_Tasks.end(),
[this](const decltype(m_Tasks)::value_type & a_Task)
{
return a_Task.first >= m_UpTime;
});
// Cut all the due tasks from m_Tasks into Tasks:
Tasks.insert(
Tasks.end(), std::make_move_iterator(MoveBeginIterator),
std::make_move_iterator(m_Tasks.end()));
m_Tasks.erase(MoveBeginIterator, m_Tasks.end());
}
// Execute each task:
for (const auto & Task : Tasks)
{
Task.second(*this);
} // for itr - m_Tasks[]
}
|
// license:BSD-3-Clause
// copyright-holders:AJR
/**********************************************************************
This 8251-based RS232 compatible serial interface is described
in the article "Cross-Pollinating the Apple II" by Richard
Campbell, BYTE Volume 4 Number 4, April 1979, pages 20-25. It
works more as a proof of concept than a full-featured peripheral.
Rates are generated by the MM5307AA based on an 895 kHz division
of the bus clock, since no onboard oscillator is provided. The
resulting data rates are, as the author notes, “3 percent low,
but in practice this is close enough.”
Only TXD and RXD are connected to the 1488 driver and 1489
receiver, though, as the author admits, they have enough spare
pins that modem control signals could be easily added.
***********************************************************************
List of integrated circuits (complete)
No. Type Function
--- ---- --------
IC1 74LS04 Invert read and reset signals from Apple bus
IC2 8251 Serial-to-parallel/parallel-to-serial conversion
IC3 74LS161 Divide 7 MHz Apple bus signal by 8
IC4 MM5307AA Data rate generation
IC5 LM1488 TTL to RS232 level conversion (TXD)
IC6 LM1489 RS232 to TTL level conversion (RXD)
**********************************************************************/
#include "emu.h"
#include "byte8251.h"
#include "bus/rs232/rs232.h"
#include "machine/i8251.h"
#include "machine/mm5307.h"
namespace {
class a2bus_byte8251_device : public device_t, public device_a2bus_card_interface
{
public:
// construction/destruction
a2bus_byte8251_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
DECLARE_INPUT_CHANGED_MEMBER(rate_changed);
protected:
// device-level overrides
virtual void device_start() override;
virtual void device_reset() override;
virtual ioport_constructor device_input_ports() const override;
virtual void device_add_mconfig(machine_config &config) override;
// device_a2bus_card_interface overrides
virtual u8 read_c0nx(u8 offset) override;
virtual void write_c0nx(u8 offset, u8 data) override;
virtual bool take_c800() override { return false; }
private:
// object finders
required_device<i8251_device> m_usart;
required_device<mm5307_device> m_brg;
required_ioport m_switches;
};
a2bus_byte8251_device::a2bus_byte8251_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock)
: device_t(mconfig, A2BUS_BYTE8251, tag, owner, clock)
, device_a2bus_card_interface(mconfig, *this)
, m_usart(*this, "8251")
, m_brg(*this, "brg")
, m_switches(*this, "SWITCHES")
{
}
void a2bus_byte8251_device::device_start()
{
// CTS grounded
m_usart->write_cts(0);
}
void a2bus_byte8251_device::device_reset()
{
// Update data rate
m_brg->control_w(m_switches->read());
}
INPUT_CHANGED_MEMBER(a2bus_byte8251_device::rate_changed)
{
m_brg->control_w(newval);
}
u8 a2bus_byte8251_device::read_c0nx(u8 offset)
{
return m_usart->read(offset & 1);
}
void a2bus_byte8251_device::write_c0nx(u8 offset, u8 data)
{
m_usart->write(offset & 1, data);
}
static INPUT_PORTS_START(byte8251)
PORT_START("SWITCHES") // “A dual in line pin-type switch may be used”
PORT_DIPNAME(0xf, 0xf, "Data Rate") PORT_DIPLOCATION("S:1,2,3,4") PORT_CHANGED_MEMBER(DEVICE_SELF, a2bus_byte8251_device, rate_changed, 0)
PORT_DIPSETTING(0x1, "50 bps")
PORT_DIPSETTING(0x2, "75 bps")
PORT_DIPSETTING(0x3, "110 bps")
PORT_DIPSETTING(0x4, "134.5 bps")
PORT_DIPSETTING(0x5, "150 bps")
PORT_DIPSETTING(0x6, "300 bps")
PORT_DIPSETTING(0x7, "600 bps")
PORT_DIPSETTING(0x8, "900 bps")
PORT_DIPSETTING(0x9, "1200 bps")
PORT_DIPSETTING(0xa, "1800 bps")
PORT_DIPSETTING(0xb, "2400 bps")
PORT_DIPSETTING(0xc, "3600 bps")
PORT_DIPSETTING(0xd, "4800 bps")
PORT_DIPSETTING(0xe, "7200 bps")
PORT_DIPSETTING(0xf, "9600 bps")
INPUT_PORTS_END
ioport_constructor a2bus_byte8251_device::device_input_ports() const
{
return INPUT_PORTS_NAME(byte8251);
}
void a2bus_byte8251_device::device_add_mconfig(machine_config &config)
{
I8251(config, m_usart, 1021800); // CLK tied to ϕ1 signal from bus pin 38
m_usart->txd_handler().set("rs232", FUNC(rs232_port_device::write_txd));
MM5307AA(config, m_brg, A2BUS_7M_CLOCK / 8);
m_brg->output_cb().set(m_usart, FUNC(i8251_device::write_txc));
m_brg->output_cb().append(m_usart, FUNC(i8251_device::write_rxc));
rs232_port_device &rs232(RS232_PORT(config, "rs232", default_rs232_devices, nullptr));
rs232.rxd_handler().set(m_usart, FUNC(i8251_device::write_rxd));
}
} // aonymous namespace
// device type definition
DEFINE_DEVICE_TYPE_PRIVATE(A2BUS_BYTE8251, device_a2bus_card_interface, a2bus_byte8251_device, "a2bus_byte8251", "BYTE Serial Interface (8251 based)")
|
; A120799: 3^(n^2)-2^n.
; Submitted by Jon Maiga
; 0,1,77,19675,43046705,847288609411,150094635296999057,239299329230617529589955,3433683820292512484657849089025,443426488243037769948249630619149892291,515377520732011331036461129765621272702107520977,5391030899743293631239539488528815119194426882613553317155,507528786056415600719754159741696356908742250191663887263627442110785,430023359390034222082732011948356798311147247214997695270038813781532497547413091
mov $1,3
pow $1,$0
pow $1,$0
mov $2,2
pow $2,$0
sub $1,$2
mov $0,$1
|
; ===============================================================
; Jun 2007
; ===============================================================
;
; void *zx_saddrpup(void *saddr)
;
; Modify screen address to move up one pixel.
;
; ===============================================================
SECTION code_clib
SECTION code_arch
PUBLIC old_zx_saddrpup
old_zx_saddrpup:
; enter : hl = screen address
;
; exit : hl = screen address moved up one pixel
; carry set if new screen address is off screen
;
; uses : af, hl
ld a,h
dec h
and $07
ret nz
ld a,$08
add a,h
ld h,a
ld a,l
sub $20
ld l,a
ret nc
ld a,h
sub $08
ld h,a
and $18
cp $18
ccf
ret
|
map_header SafariZoneEastRestHouse, SAFARI_ZONE_EAST_REST_HOUSE, GATE, 0
end_map_header
|
/****************************************************************************
Copyright (c) 2015 Cognitics, Inc.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
****************************************************************************/
#include "dbi_sqlite/File.h"
namespace dbi
{
namespace sqlite
{
File::File()
{
log.init("dbi_sqlite::File", this);
log << ccl::LINFO;
db = NULL;
}
File::~File()
{
if (db)
{
sqlite3_close(db);
}
}
bool File::connect(const std::string &filename)
{
// Create the sql lite file if it doesn't exist
// Try opening an existing file, or create it
if (sqlite3_open_v2(filename.c_str(), &db, SQLITE_OPEN_URI | SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE, NULL))
{
// log << ccl::LERR << "Error: Unable to open or create " << filename << ". Error is " << std::string(sqlite3_errmsg(db)) << log.endl;
return false;
}
sqlite3_enable_load_extension(db,1);
return true;
}
bool File::create(const std::string &filename)
{
// Create the sql lite file if it doesn't exist
// Try opening an existing file, or create it
if (sqlite3_open_v2(filename.c_str(), &db, SQLITE_OPEN_URI | SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL))
{
// log << ccl::LERR << "Error: Unable to open or create " << filename << ". Error is " << std::string(sqlite3_errmsg(db)) << log.endl;
return false;
}
sqlite3_enable_load_extension(db, 1);
return true;
}
Statement *File::createStatement()
{
return new Statement(this);
}
void File::destroyStatement(Statement *stmt)
{
delete stmt;
}
}
} |
; A225566: The set of magic numbers for an idealized harmonic oscillator atomic nucleus with a biaxially deformed prolate ellipsoid shape and an oscillator ratio of 3:1
; 2,4,6,12,18,24,36,48,60,80,100,120,150,180,210,252,294,336,392,448,504,576,648,720,810,900,990,1100,1210,1320,1452,1584,1716,1872,2028,2184,2366,2548,2730,2940,3150,3360,3600,3840,4080,4352,4624,4896,5202,5508,5814,6156,6498,6840,7220,7600,7980,8400,8820,9240,9702,10164,10626,11132,11638,12144,12696,13248,13800,14400,15000,15600,16250,16900,17550,18252,18954,19656,20412,21168,21924,22736,23548,24360,25230,26100,26970,27900,28830,29760,30752,31744,32736,33792,34848,35904,37026,38148,39270,40460,41650,42840,44100,45360,46620,47952,49284,50616,52022,53428,54834,56316,57798,59280,60840,62400,63960,65600,67240,68880,70602,72324,74046,75852,77658,79464,81356,83248,85140,87120,89100,91080,93150,95220,97290,99452,101614,103776,106032,108288,110544,112896,115248,117600,120050,122500,124950,127500,130050,132600,135252,137904,140556,143312,146068,148824,151686,154548,157410,160380,163350,166320,169400,172480,175560,178752,181944,185136,188442,191748,195054,198476,201898,205320,208860,212400,215940,219600,223260,226920,230702,234484,238266,242172,246078,249984,254016,258048,262080,266240,270400,274560,278850,283140,287430,291852,296274,300696,305252,309808,314364,319056,323748,328440,333270,338100,342930,347900,352870,357840,362952,368064,373176,378432,383688,388944,394346,399748,405150,410700,416250,421800,427500,433200,438900,444752,450604,456456,462462,468468,474474,480636,486798,492960,499280,505600,511920,518400,524880,531360,538002,544644,551286,558092,564898,571704,578676,585648,592620,599760
add $0,2
lpb $0
add $2,$0
sub $0,3
sub $2,1
add $3,2
lpb $2
add $1,$3
sub $2,1
lpe
lpe
|
; void sp1_IterateUpdateRect(struct sp1_Rect *r, void *hook)
SECTION code_temp_sp1
PUBLIC _sp1_IterateUpdateRect
_sp1_IterateUpdateRect:
pop af
pop hl
pop bc
push bc
push hl
push af
push bc
ld d,(hl)
inc hl
ld e,(hl)
inc hl
ld b,(hl)
inc hl
ld c,(hl)
ex (sp),ix
call asm_sp1_IterateUpdateRect
pop ix
ret
INCLUDE "temp/sp1/zx/updater/asm_sp1_IterateUpdateRect.asm"
|
boot_bz equ 0x7dbe;第一分区项引导标志的内存地址
data_fqsj equ 0x7000;保存主引导分区信息的数据段
org 0x7c00
start:;主引导代码
;获取当前引导设备的设备号
mov byte [data_fqsj+4],dl
;获取第一分区项引导标志的地址 [ds:di]
mov bx, boot_bz
mov ch, 1
pd_boot:
cmp ch, 4
jg boot_error;如果没找到主引导分区就抱引导错误
mov di, bx
mov ax, 0x00
mov ds, ax
;判断是否是引导扇区
mov ah, byte [ds:di]
cmp ah, 0x80
je boot_fq;如果是引导分区则引导
jne fq_add;如果不是引导分区则判断下一个分区
jmp boot_error
fq_add:;获取下一个分区项引导标志的内存地址
add bx, 16
add ch, 1
jmp pd_boot
boot_fq:;进入引导,得到了ch存储的是主引导分区的分区项，bx主引导扇区分区项的所在地址
call fqxx;获取分区信息
call hq_xx;获取其他信息
call read;读取分区的第一扇区
jmp 0x00:0x7e00;进入分区引导
read:;读取分区的第一扇区
push ax
push bx
push cx
push dx
push es
push ds
mov ax, 0x07e0
mov es, ax
mov ax, 0x00
mov ds, ax
mov ch, byte [ds:data_fqsj+2]
mov dh, byte [ds:data_fqsj]
mov cl, byte [ds:data_fqsj+1]
mov ah, 0x02
mov al, 1
mov bx, 0x00
mov dl, byte [ds:data_fqsj+4]
int 0x13
pop ds
pop es
pop dx
pop cx
pop bx
pop ax
ret
boot_error:;引导错误
mov ax, 0xb800
mov ds, ax
mov byte [ds:0x00], 'E'
mov byte [ds:0x01], 0x07
mov byte [ds:0x02], 'r'
mov byte [ds:0x03], 0x07
mov byte [ds:0x04], 'r'
mov byte [ds:0x05], 0x07
mov byte [ds:0x06], 'o'
mov byte [ds:0x07], 0x07
mov byte [ds:0x08], 'r'
mov byte [ds:0x09], 0x07
jmp boot_error
fqxx:;读取分区信息
push ax
push bx
push cx
push dx
;段寄存器初始化
mov ax, 0x00
mov ds, ax
;得到分区的起始位置磁头
add bx, 1
mov dl, byte [ds:bx]
mov byte [ds:data_fqsj], dl
;得到分区的起始位置扇区
add bx, 1
mov dl, byte [ds:bx]
mov byte [ds:data_fqsj+1], dl
;得到分区的起始位置柱面
add bx, 1
mov dl, byte [ds:bx]
mov byte [ds:data_fqsj+2], dl
pop dx
pop cx
pop bx
pop ax
ret
hq_xx:;获取其他信息
ret
;mbr分区表
times 446-($-$$) db 0
;第一分区项
db 0x00
db 0x00, 0x00, 0x00
db 0x00
db 0x00, 0x00, 0x00
db 0x00, 0x00, 0x00, 0x00
db 0x00, 0x00, 0x00, 0x00
;第二分区项
db 0x80
db 0x00, 0x07, 0x00
db 0xff
db 0x01, 0xff, 0xff
db 0x00, 0x00, 0x00, 0x06
db 0x00, 0x00, 0xfb, 0xbb
;第三分区项
db 0x00
db 0x00, 0x00, 0x00
db 0x00
db 0x02, 0x00, 0x00
db 0x00, 0x00, 0x00, 0x00
db 0x00, 0x00, 0x00, 0x00
;第四分区项
db 0x02
db 0x05, 0x01, 0x02
db 0x02
db 0x02, 0x01, 0x00
db 0x02, 0x02, 0xfc, 0x05
db 0x02, 0x01, 0xf7, 0x82
;引导扇区有效标志
times 510-($-$$) db 0
db 0x55, 0xaa
|
; Returns SGN (SIGN) for 8 bits unsigned integera
__SGNU8:
or a
ret z
ld a, 1
ret
|
; A091483: a(n) = (4*n)^n.
; 1,4,64,1728,65536,3200000,191102976,13492928512,1099511627776,101559956668416,10485760000000000,1196683881290399744,149587343098087735296,20325604337285010030592,2982856619293778479415296,470184984576000000000000000,79228162514264337593543950336,14211879482945166685530717421568,2703864574375502950215699413336064,543823854004776201625079750041010176
mov $1,4
mul $1,$0
pow $1,$0
mov $0,$1
|
; A084130: a(n) = 8a(n-1)-8a(n-2), a(0)=1, a(1)=4.
; 1,4,24,160,1088,7424,50688,346112,2363392,16138240,110198784,752484352,5138284544,35086401536,239584935936,1635988275200,11171226714112,76281907511296,520885446377472,3556828310929408,24287542916415488
mov $1,1
mov $3,1
lpb $0,1
sub $0,1
mul $1,2
mov $2,$1
sub $1,$1
add $3,1
mul $3,2
sub $3,2
mul $3,2
add $1,$3
add $3,$1
sub $3,$2
lpe
|
;
; Sharp OZ family functions
;
; ported from the OZ-7xx SDK by by Alexander R. Pruss
; by Stefano Bodrato - Oct. 2003
;
;
;
; ------
; $Id: ozexitto.asm,v 1.4 2016/06/28 14:48:17 dom Exp $
;
SECTION code_clib
PUBLIC ozexitto
PUBLIC _ozexitto
EXTERN ozkeyclear
EXTERN ozungetch2
EXTERN cleanup ;exit
ozexitto:
_ozexitto:
call ozkeyclear
pop bc ;; retval
pop hl ;; key
push hl ;; put two copies of key on stack
push hl
call ozungetch2
pop hl ;; use previous copy of key on stack as argument
call ozungetch2
jp cleanup
|
; A015579: Expansion of x/(1-9*x-2*x^2).
; Submitted by Jamie Morken(s4)
; 0,1,9,83,765,7051,64989,599003,5521005,50887051,469025469,4323003323,39845080845,367251734251,3384955769949,31199105398043,287561860122285,2650454951896651,24429218287314429,225163874489623163,2075333306981237325,19128327511810382251,176305614220255914909,1625007183005923998683,14977675875493827817965,138049097245456298359051,1272397226960094340867389,11727673237131761664524603,108093853588106043662456205,996300028767217916291155051,9182887966081173333945307869,84638591752264995838090080923
mov $1,1
lpb $0
sub $0,1
mov $2,$3
mul $2,2
mul $3,9
add $3,$1
mov $1,$2
lpe
mov $0,$3
|
###############################################################################
# Copyright 2018 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material ("Material") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
.text
.p2align 5, 0x90
.globl _l9_cpInc_BNU
_l9_cpInc_BNU:
movslq %edx, %rdx
movq (%rsi), %r8
add %rcx, %r8
movq %r8, (%rdi)
lea (%rsi,%rdx,8), %rsi
lea (%rdi,%rdx,8), %rdi
lea (,%rdx,8), %rcx
sbb %rax, %rax
neg %rcx
add $(8), %rcx
jrcxz .Lexitgas_1
add %rax, %rax
jnc .Lcopygas_1
.p2align 5, 0x90
.Linc_loopgas_1:
movq (%rsi,%rcx), %r8
adc $(0), %r8
movq %r8, (%rdi,%rcx)
lea (8)(%rcx), %rcx
jrcxz .Lexit_loopgas_1
jnc .Lexit_loopgas_1
jmp .Linc_loopgas_1
.Lexit_loopgas_1:
sbb %rax, %rax
.Lcopygas_1:
cmp %rdi, %rsi
jz .Lexitgas_1
jrcxz .Lexitgas_1
.Lcopy_loopgas_1:
movq (%rsi,%rcx), %r8
movq %r8, (%rdi,%rcx)
add $(8), %rcx
jnz .Lcopy_loopgas_1
.Lexitgas_1:
neg %rax
vzeroupper
ret
.p2align 5, 0x90
.globl _l9_cpDec_BNU
_l9_cpDec_BNU:
movslq %edx, %rdx
movq (%rsi), %r8
sub %rcx, %r8
movq %r8, (%rdi)
lea (%rsi,%rdx,8), %rsi
lea (%rdi,%rdx,8), %rdi
lea (,%rdx,8), %rcx
sbb %rax, %rax
neg %rcx
add $(8), %rcx
jrcxz .Lexitgas_2
add %rax, %rax
jnc .Lcopygas_2
.p2align 5, 0x90
.Linc_loopgas_2:
movq (%rsi,%rcx), %r8
sbb $(0), %r8
movq %r8, (%rdi,%rcx)
lea (8)(%rcx), %rcx
jrcxz .Lexit_loopgas_2
jnc .Lexit_loopgas_2
jmp .Linc_loopgas_2
.Lexit_loopgas_2:
sbb %rax, %rax
.Lcopygas_2:
cmp %rdi, %rsi
jz .Lexitgas_2
jrcxz .Lexitgas_2
.Lcopy_loopgas_2:
movq (%rsi,%rcx), %r8
movq %r8, (%rdi,%rcx)
add $(8), %rcx
jnz .Lcopy_loopgas_2
.Lexitgas_2:
neg %rax
vzeroupper
ret
|
#ifndef _NETWORK_H_
#define _NETWORK_H_
#include <sys/types.h>
#include <sys/socket.h>
#include <iostream>
#include <vector>
enum ConnType { TCPCONN, UDPCONN };
class NetworkConnection
{
public:
// Constructor
NetworkConnection();
// Constructor with params.
NetworkConnection(ConnType ctype, std::string address, uint16_t port);
// Desctructor
~NetworkConnection();
// Copy constructor
NetworkConnection(NetworkConnection &source);
// Assignment operator
void operator=(NetworkConnection &source);
// For a string rep of the object
void Print(std::ostream *os);
// Setters
void SetAddress(std::string address);
void SetPort(uint16_t port);
void SetConnType(ConnType ctype);
// Getters
std::string GetAddress();
uint16_t GetPort();
ConnType GetConnType();
private:
// The type of connection
ConnType conntype;
// Reusable Copy method
void Copy(NetworkConnection &source);
// Remote host
std::string address;
// Remote port
uint16_t port;
};
std::ostream &operator<<(std::ostream &os, NetworkConnection &conn);
/*
* A manager for multiple sockets, either as a client or server
* depending on how it was invoked.
*/
class NetworkManager
{
public:
// Construtor
NetworkManager();
// Copy constructor
NetworkManager(NetworkManager &source);
// Destructor
~NetworkManager(void);
// Assignment operator
void operator=(NetworkManager &source);
// A print method for sending data an iostream
void Print(std::ostream *os);
private:
// The list of current connections
std::vector<NetworkConnection*> connections;
// Reusable Copy method
void Copy(NetworkManager &source);
};
std::ostream &operator<<(std::ostream &os, NetworkManager &manager);
class TcpNetworkManager: public NetworkManager
{
public:
TcpNetworkManager();
~TcpNetworkManager();
private:
};
std::ostream &operator<<(std::ostream &os, TcpNetworkManager &manager);
class UdpNetworkManager: public NetworkManager
{
public:
UdpNetworkManager();
~UdpNetworkManager();
private:
};
std::ostream &operator<<(std::ostream &os, UdpNetworkManager &manager);
#endif
|
;; $Header: /cvsroot/uuu/uuu/src/cells/memory_manager/meitnerium/meitnerium.asm,v 1.9 2001/12/07 01:46:30 daboy Exp $
;;
;; Meitnerium memory manager cell
;; Copyright (c) 2001 Phil Frost
;; Distributed under the BSD license, see file 'license' for details.
;;
;; when to use this cell:
;; ----------------------
;; Use this cell when you want to allocate lotts of fairly small, fixed size
;; memory chunks. This has 2 advantages; it doesn't fragment memory, it's MUCH
;; faster, and less memory is wasted for overhead. Dealloc is somewhat
;; not-hyper-fast (but it's probally just as deallocing with oxygen); this was
;; a tradeoff for less memory overhead.
;;
;; short description of how this works:
;; ------------------------------------
;; linked list'o'rama! Memory is requested from oxygen in "chunks" which
;; contain any power of 2 blocks of a user-specified size. The first chunk
;; allocated has a 12 byte header "root_chunk", and a normal chunk procedes
;; right after that.
;;
;; The chunks are linked together in 2 ways. There is a linked list of all the
;; chunks just so we can dealloc them, and there is a linked list of the chunks
;; with free blocks so we can alloc quickly. The root chunk is oviously the
;; first chunk in the first list, but the first chunk in the chunks with free
;; blocks list is stored in root_chunk.first_free.
;;
;; Inside each chunk is a counter of the availible blocks. This is used to
;; determine when the chunk is full, and when it was full and one block was
;; dealloced (in this case it needs to be added to the free chunks list)
;;
;; In each chunk is also a linked list of the free blocks. The first free block
;; is in chunk.next_free_block. If the free blocks count is zero this value is
;; ignored. Then, inside each free block is a pointer to the next free block;
;; once again the last one need not have a null because the free block count is
;; used.
; -----------------------------------
; defines
;==============================================================================
;%define _DEBUG_
; -----------------------------------
; includes
;==============================================================================
%include "vid/mem.inc"
%include "vid/mem.fixed.inc"
; -----------------------------------
; strucs
;==============================================================================
struc root_chunk
.block_size: resd 1 ; size of the fixed size blocks
.block_count: resd 1 ; number of blocks / chunk as power of 2
.first_free: resd 1 ; ptr to first chunk in the free chunk chain
endstruc
struc chunk
.next: resd 1 ; ptr to next chunk in the chain; 0 for none
.next_free: resd 1 ; ptr to next chunk in the free chunk chain
.next_free_block: resd 1 ; ptr to next free block in this chunk
.free_blocks: resd 1 ; number of free blocks in this chunk
endstruc
; -----------------------------------
; section .text
;==============================================================================
section .text
; -----------------------------------
; mem.fixed.alloc_space
;==============================================================================
globalfunc mem.fixed.alloc_space
;>
;; This function initializes space for a group of fixed size blocks. It must be
;; called once before allocating fixed size blocks. ECX, the number of blocks
;; to reserve at a time, determines how many of the smaller fixed size blocks
;; are in each larger block. So, if ECX = 32 and ECX = 4, memory will be
;; allocated in 32*2^4 byte blocks (plus any overhead). Smaller values mean less
;; wasted memory due to reserved, but not used memory; larger values mean less
;; wasted memory due to the overhead of Meitnerium and Oxygen.
;;
;; This function needs to be called only once to set up the space; it will be
;; expanded as needed by Meitnerium.
;;
;; parameters:
;; -----------
;; EDX = size of blocks to be allocated, must be at least 4 bytes
;; ECX = number of blocks to reserve at a time as a power of two, so a value of
;; 4 would allocate room for 16 blocks at a time (must be != 0)
;;
;; returned values:
;; ----------------
;; EDI = pointer to root block; use this in calls to other Meitnerium functions
;; errors as usual
;; registers saved as usual
;<
pushad
shl edx, cl
lea ecx, [edx + root_chunk_size + chunk_size]
dbg_print "allocating 0x",1
dbg_print_hex ecx
dbg_print " bytes of RAM for root chunk",0
externfunc mem.alloc
mov edx, [esp+20]
mov ecx, [esp+24]
jc .end
xor eax, eax
mov [edi+root_chunk.block_size], edx
lea esi, [edi+root_chunk_size]
mov [edi+root_chunk.block_count], ecx
mov [edi+root_chunk.first_free], esi
mov [edi+root_chunk_size+chunk.next], eax
mov [edi+root_chunk_size+chunk.next_free], eax
add esi, byte chunk_size
mov [edi+root_chunk_size+chunk.next_free_block], esi
inc eax
shl eax, cl
mov [edi+root_chunk_size+chunk.free_blocks], eax
lea ebp, [esi+edx]
.loop:
mov [esi], ebp
add esi, edx
add ebp, edx
dec eax
jnz .loop
.end:
dbg_print "allocated root chunk at 0x",1
dbg_print_hex edi
dbg_term_log
mov esi, [esp+4]
mov ebp, [esp+8]
mov ebx, [esp+16]
add esp, byte 32
retn
; -----------------------------------
; mem.fixed.alloc
;==============================================================================
globalfunc mem.fixed.alloc
;>
;; Allocates a fixed size memory block from a previously allocated
;; fixed_size_block_space
;;
;; parameters:
;; -----------
;; EDI = pointer to fixed size block space
;;
;; returned values:
;; ----------------
;; EDI = pointer to allocated block
;; errors as usual
;; registers saved as usual
;<
push ebp
push esi
mov esi, edi
mov ebp, [esi+root_chunk.first_free] ; EBP= ptr to first chunk w/ free blocks
test ebp, ebp ; unless it's 0, then there is none
jz .make_new_chunk
mov edi, [ebp+chunk.next_free_block]
mov eax, [edi]
mov [ebp+chunk.next_free_block], eax
dec dword[ebp+chunk.free_blocks]
jz .filled_chunk
clc
pop esi
pop ebp
retn
.filled_chunk:
mov eax, [ebp+chunk.next_free]
mov [esi+root_chunk.first_free], eax
dbg_print "allocated block at 0x",1
dbg_print_hex edi
dbg_term_log
clc
pop ebp
pop esi
retn
.make_new_chunk: ; we have run out of free chunks, so make a new one
dbg_print "making a new chunk",0
pushad
mov edx, [esi+root_chunk.block_size]
mov ecx, [esi+root_chunk.block_count]
push edx
shl edx, cl
push ecx
lea ecx, [edx + chunk_size]
externfunc mem.alloc
pop ecx
pop edx
jc .end
mov [esi+root_chunk.first_free], edi
mov eax, [esi+root_chunk_size+chunk.next]
mov [edi+chunk.next], eax
mov [esi+root_chunk_size+chunk.next], edi
xor eax, eax
mov [edi+chunk.next_free], eax
inc eax
shl eax, cl ; EAX = number of blocks
dec eax ; we have already allocated one
mov [edi+chunk.free_blocks], eax
lea esi, [edi+chunk_size+edx] ; ESI = ptr to 2nd block
lea ebp, [esi+edx]
mov [edi+chunk.next_free_block], esi
.loop:
mov [esi], ebp
add esi, edx
add ebp, edx
dec eax
jnz .loop
add edi, byte chunk_size ; move pointer past the header
.end:
mov [esp], edi
popad
pop esi
pop ebp
clc
retn
; -----------------------------------
; mem.fixed.dealloc_space
;==============================================================================
globalfunc mem.fixed.dealloc_space
;>
;; deallocates a previously allocated fixed block space and all of the blocks
;; in it.
;;
;; parameters:
;; -----------
;; ESI = pointer to fixed size block space
;;
;; returned values:
;; ----------------
;; errors as usual
;; registers ARE destroyed
;<
mov ebp, [esi+root_chunk_size+chunk.next]
mov eax, esi
dbg_print "deallocing chunk at 0x",1
dbg_print_hex eax
dbg_term_log
externfunc mem.dealloc
jc .end
test ebp, ebp
jz .done
.loop:
mov eax, ebp
mov ebp, [ebp+chunk.next]
dbg_print "deallocing chunk at 0x",1
dbg_print_hex eax
dbg_term_log
externfunc mem.dealloc
jc .end
test ebp, ebp
jnz .loop
.done:
clc
.end:
retn
; -----------------------------------
; mem.fixed.dealloc
;==============================================================================
globalfunc mem.fixed.dealloc
;>
;; deallocates one fixed size block
;;
;; parameters:
;; -----------
;; EAX = pointer to fixed size block space
;; EDI = pointer to fixed size block to deallocate
;;
;; returned values:
;; ----------------
;; errors as usual
;; registers saved as usual
;<
pushad
mov edx, eax
mov eax, [edi+root_chunk.block_size]
mov ecx, [edi+root_chunk.block_count]
shl eax, cl
add eax, byte chunk_size ; EAX = total chunk size
lea ebp, [edi+root_chunk_size]; EBP = ptr to chunk to test
jmp short .loop_enter
.loop:
mov ebp, [ebp+chunk.next] ; load ptr to next chunk
test ebp, ebp ; if we hit a zero pointer we are hosed
jz .could_not_find_chunk
.loop_enter:
push edx
sub edx, ebp ; sub the base address of the chunk from edx
cmp edx, eax ; see if edx falls within the chunk
pop edx
jnbe .loop
;; EDX = ptr to block to dealloc
;; EBP = ptr to chunk block is in
;; EDI = ptr to root chunk
;; ECX = number of blocks as power of 2
mov eax, [ebp+chunk.next_free_block] ;
mov [edx], eax ; put old next in [edx]
mov [ebp+chunk.next_free_block], edx ; and edx in the new one
mov edx, [ebp+chunk.free_blocks]
test edx, edx
jnz .was_not_full
; if the chunk was previously full, add it to the free chunk chain
mov eax, [edi+root_chunk.first_free]
mov [edi+root_chunk.first_free], ebp
mov [ebp+chunk.next_free], eax
.was_not_full:
inc edx ; just dealloced one, one less free
xor eax, eax
inc eax
shl eax, cl
cmp edx, eax
jae .dealloc_whole_block
mov [ebp+chunk.free_blocks], edx
popad
clc
retn
.could_not_find_chunk:
mov eax, __ERROR_INVALID_PARAMETERS__
popad
stc
retn
.dealloc_whole_block:
; XXX should make some intelegent decision on how to dealloc here, but for
; now just leave it in; future block allocs will still use this chunk.
popad
clc
retn
; -----------------------------------
; cell info
;==============================================================================
section .c_info
db 0, 1, 0, 'a'
dd str_cellname
dd str_author
dd str_copyrights
str_cellname: dd "Meitnerium - fixed size memory block manager"
str_author: dd 'Phil Frost <daboy@xgs.dhs.org>'
str_copyrights: dd 'Copyright 2001 by Phil Frost; distributed under the BSD license'
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r14
push %r8
push %r9
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x9da1, %rbp
nop
nop
nop
sub %rbx, %rbx
mov $0x6162636465666768, %r9
movq %r9, %xmm5
movups %xmm5, (%rbp)
nop
nop
sub %rax, %rax
lea addresses_WC_ht+0x11ea1, %r8
nop
nop
nop
nop
xor %rbp, %rbp
mov (%r8), %r14w
nop
nop
nop
dec %rbx
lea addresses_D_ht+0x1dc81, %rax
nop
nop
xor $5277, %r11
movl $0x61626364, (%rax)
nop
and %rbx, %rbx
lea addresses_WC_ht+0xdbe1, %rsi
lea addresses_UC_ht+0xd9a1, %rdi
dec %r9
mov $96, %rcx
rep movsb
nop
nop
nop
nop
nop
dec %rcx
lea addresses_WC_ht+0xd3b9, %rsi
nop
nop
nop
inc %r14
mov $0x6162636465666768, %r11
movq %r11, (%rsi)
nop
nop
add $42139, %r8
lea addresses_WC_ht+0x16aa1, %rsi
lea addresses_UC_ht+0x13da1, %rdi
nop
nop
inc %r14
mov $4, %rcx
rep movsb
nop
nop
inc %rsi
lea addresses_WC_ht+0x13304, %rsi
lea addresses_WC_ht+0x15fa1, %rdi
nop
nop
and $33813, %r9
mov $118, %rcx
rep movsb
nop
nop
nop
and $27206, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r9
pop %r8
pop %r14
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %rbx
push %rcx
push %rdx
// Faulty Load
lea addresses_PSE+0x9da1, %rdx
nop
nop
nop
nop
and $23816, %r12
movb (%rdx), %bl
lea oracles, %r10
and $0xff, %rbx
shlq $12, %rbx
mov (%r10,%rbx,1), %rbx
pop %rdx
pop %rcx
pop %rbx
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_PSE', 'same': False, 'size': 16, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_PSE', 'same': True, 'size': 1, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 16, 'congruent': 10, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'same': True, 'size': 2, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_WC_ht', 'same': False, 'size': 8, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': True}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
|
.model small
.stack
.data
.code
main proc
mov ah, 01h ;singel int or charecter / digit
int 21h ; input al regester *** fixt code for input
mov bl,al
mov ah, 01h
int 21h ; input in al resister
mov cl, al ;2nd input
int 21h
mov dl, bl ;first output
mov ah , 02h ; singel char / digit
int 21h
mov dl,cl ;2nd output
mov ah, 02h
int 21h ;will show output of dl register
main endp
end main |
;; ======================================================================== ;;
;; Use EMU_DETECT interface to query emulator version. ;;
;; ======================================================================== ;;
;* ======================================================================== *;
;* This program is free software; you can redistribute it and/or modify *;
;* it under the terms of the GNU General Public License as published by *;
;* the Free Software Foundation; either version 2 of the License, or *;
;* (at your option) any later version. *;
;* *;
;* This program is distributed in the hope that it will be useful, *;
;* but WITHOUT ANY WARRANTY; without even the implied warranty of *;
;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *;
;* General Public License for more details. *;
;* *;
;* You should have received a copy of the GNU General Public License along *;
;* with this program; if not, write to the Free Software Foundation, Inc., *;
;* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *;
;* ======================================================================== *;
;* Copyright (c) 2006, Joseph Zbiciak *;
;* ======================================================================== *;
ROMW 16 ; Use 16-bit ROM width
CFGVAR "name" = "Emulator Detect"
CFGVAR "year" = 2006
CFGVAR "author" = "Joe Zbiciak"
CFGVAR "license" = "GPLv2+"
;; ======================================================================== ;;
;; Macros and definitions ;;
;; ======================================================================== ;;
INCLUDE "library/gimini.asm"
INCLUDE "macro/util.mac"
INCLUDE "macro/stic.mac"
INCLUDE "macro/gfx.mac"
INCLUDE "macro/print.mac"
ORG $5000 ; Use default memory map
;; ======================================================================== ;;
;; EXEC-friendly ROM header. ;;
;; ======================================================================== ;;
ROMHDR: BIDECLE ZERO ; MOB picture base (points to NULL list)
BIDECLE ZERO ; Process table (points to NULL list)
BIDECLE MAIN ; Program start address
BIDECLE ZERO ; Bkgnd picture base (points to NULL list)
BIDECLE ONES ; GRAM pictures (points to NULL list)
BIDECLE TITLE ; Cartridge title/date
DECLE $03C0 ; No ECS title, run code after title,
; ... no clicks
ZERO: DECLE $0000 ; Screen border control
DECLE $0000 ; 0 = color stack, 1 = f/b mode
ONES: DECLE 1, 1, 1, 1, 1 ; Initial color stack 0..3 and border: blue
;------------------------------------------------------------------------------
MACRO ps16(a)
((ASC(%a%,0) SHL 8) OR (ASC(%a%,1)))
ENDM
;; ======================================================================== ;;
;; Known emulators: ;;
;; ======================================================================== ;;
EMUTBL PROC
DECLE ps16("JZ"), @@jzintv
DECLE ps16("KI"), @@kinty
DECLE ps16("BL"), @@bliss
DECLE ps16("NO"), @@nost
DECLE ps16("IW"), @@intvwin
DECLE ps16("ID"), @@intvdos
DECLE ps16("IP"), @@intvpc
@@last
@@jzintv STRING 'jzIntv',0
@@kinty STRING 'KInty', 0
@@bliss STRING 'Bliss', 0
@@nost STRING 'Nostalgia', 0
@@intvwin STRING 'IntvWin', 0
@@intvdos STRING 'IntvDOS', 0
@@intvpc STRING 'IntvPC', 0
ENDP
;; ======================================================================== ;;
;; TITLE -- Display our modified title screen & copyright date. ;;
;; ======================================================================== ;;
TITLE: PROC
BYTE 106, 'Emu Detect', 0
MAIN:
CALL CLRSCR
SETISR ISR, R0
EIS
;; ------------------------------------------------------------ ;;
;; Check for EMU_LINK support. ;;
;; ------------------------------------------------------------ ;;
MVII #$656D, R0 ; \_ "em"
MVII #$753F, R1 ; / "u?"
SETC
SIN
BNC @@ok
;; ------------------------------------------------------------ ;;
;; Print failure message if we don't detect an emulator ;;
;; ------------------------------------------------------------ ;;
;0123456789012345678901234567890123456789
PRINT_CSTK 6, 5, YEL, "No emulator detected"
DECR PC
@@ok:
;; ------------------------------------------------------------ ;;
;; See what emulator it is. ;;
;; ------------------------------------------------------------ ;;
MVII #EMUTBL,R4
PSHR R1
@@loop: CMP@ R4, R0
BEQ @@found_it
INCR R4
CMPI #EMUTBL.last, R4
BNC @@loop
;0123456789012345678901234567890123456789
PRINT_CSTK 4, 5, YEL, " Unrecognized emulator detected:"
MVII #C_WHT, R1
MVII #disp_ptr(7, 5), R4
CALL HEX16
PULR R0
MVII #C_WHT, R1
MVII #disp_ptr(7, 11), R4
CALL HEX16
DECR PC
@@found_it:
MVI@ R4, R5 ; Pointer to name
MOVR R5, R0
MVII #disp_ptr(6, 10)*2+1,R3
CLRR R2
@@center_lp:
DECR R3
CMP@ R5, R2
BNEQ @@center_lp
SLR R3, 1
MOVR R3, R4
MVII #C_YEL, R1
CALL PRINT.R
PULR R0
MVII #C_YEL, R1
MVII #disp_ptr(7, 8), R4
CALL HEX16
DECR PC
ENDP
;; ======================================================================== ;;
;; ISR ;;
;; ======================================================================== ;;
ISR PROC
MVO R0, $20
MVII #__CSTK.GROM_BLU, R0
MVII #$28, R4
MVO@ R0, R4
MVO@ R0, R4
MVO@ R0, R4
MVO@ R0, R4
MVO@ R0, R4
JR R5
ENDP
;; ======================================================================== ;;
;; LIBRARY INCLUDES ;;
;; ======================================================================== ;;
INCLUDE "library/print.asm"
INCLUDE "library/fillmem.asm"
INCLUDE "library/prnum16.asm"
INCLUDE "library/hexdisp.asm"
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r13
push %r15
push %r8
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x186cb, %rdi
nop
add $39538, %r15
movups (%rdi), %xmm2
vpextrq $0, %xmm2, %r13
nop
nop
nop
nop
and %r10, %r10
lea addresses_normal_ht+0x126cb, %rsi
lea addresses_WC_ht+0x5513, %rdi
clflush (%rdi)
nop
nop
nop
nop
and $5350, %r8
mov $86, %rcx
rep movsq
nop
nop
cmp %r8, %r8
lea addresses_A_ht+0x14fff, %rdi
nop
inc %rsi
mov (%rdi), %r13d
nop
nop
nop
nop
nop
cmp $13397, %r15
lea addresses_UC_ht+0x52cb, %rsi
nop
nop
and $10998, %r15
mov $0x6162636465666768, %r13
movq %r13, (%rsi)
nop
nop
nop
nop
nop
sub $62049, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %r8
pop %r15
pop %r13
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %rax
push %rbp
push %rcx
push %rdi
push %rdx
// Load
lea addresses_UC+0x147cf, %rax
nop
nop
nop
nop
and %r12, %r12
mov (%rax), %rbp
nop
nop
nop
inc %rbp
// Faulty Load
lea addresses_UC+0x86cb, %rcx
nop
cmp $24841, %rdi
movups (%rcx), %xmm3
vpextrq $1, %xmm3, %r12
lea oracles, %rbp
and $0xff, %r12
shlq $12, %r12
mov (%rbp,%r12,1), %r12
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_UC', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_UC', 'size': 8, 'AVXalign': True}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_UC', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 11, 'NT': False, 'type': 'addresses_normal_ht', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 10, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': False}}
{'src': {'same': False, 'congruent': 2, 'NT': False, 'type': 'addresses_A_ht', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 10, 'NT': False, 'type': 'addresses_UC_ht', 'size': 8, 'AVXalign': False}}
{'37': 21829}
37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37
*/
|
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) Geoworks 1995 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Kernel
FILE: geodesPatchCoreBlock.asm
AUTHOR: Paul Canavese, Jan 27, 1995
ROUTINES:
Name Description
---- -----------
(See geodesPatch.asm for an overview to the patching code.)
INITIALIZE A GEODE PATCH
A geode's core block needs to be modified to allow patching to work
correctly.
If the geode in non-XIP and is just being loaded in, we reallocate the
core block (GeodePatchReAllocCoreBlock) and apply the patch
(GeodePatchCoreBlock). The rest of the work will be done
automatically by the regular geode loading mechanism, which will call
our routines to read in the allocation flags for new resources and get
the proper resource size for changed resources.
GeodePatchReadAllocationFlags Copy the allocation flags for
any new resources onto the stack.
GeodeGetPatchedResourceSize Return the proper resource
size of a resource, if it's patched.
If the geode was loaded into memory before the patch code had a chance
to run, all of the following routines must be run.
If the geode is XIP, all of the following routines must be called,
since the XIP loading code will not take care of it.
GeodePatchModifyCoreBlock* Modify a core block for an XIP
geode, or any geode that is already in
memory.
-------------------------------------------------------------
GeodePatchReAllocCoreBlock Reallocate the core block
larger to provide room for additional
entry points and resources, if
necessary.
GeodePatchCoreBlock Apply patch to the core block (if
patch exists), and recalculate
pointers to geode tables if
resources were added.
GeodePatchInitNewResources* Allocate any resources that
don't already exist for this geode
(that only exist in the patched
version).
GeodePatchPreLoadNewResources* Preload resources that exist
only in the patch file and are
supposed to be preloaded (i.e. not
discarded).
GeodePatchRelocateNewExportEntries* Relocate those
parts of the export table that have
been patched.
* These routines are in geodesPatchXIP.asm
REVISION HISTORY:
Name Date Description
---- ---- -----------
PC 1/27/95 Initial revision
DESCRIPTION:
Code to modify a geode's core block to allow patching.
$Id: geodesPatchCoreBlock.asm,v 1.1 97/04/05 01:12:25 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
GLoad segment resource
if USE_PATCHES
if USE_BUG_PATCHES
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
GeodePatchReadAllocationFlags
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Copy the allocation flags for any new resources onto
the stack
CALLED BY: InitResources
PASS: ss:dx - pointer to flags list
ds - core block
es - kdata
RETURN: nothing
DESTROYED: ax,bx,cx,dx,si
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
chrisb 1/20/94 Initial version.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
GeodePatchReadAllocationFlags proc far
EC < call ECCheckCoreBlockDS >
EC < call ECCheckDGroupES >
uses es, di
.enter
; If there are no new resources, we're done.
call GeodeGetGeneralPatchBlock
; es = Patch data segment.
tst es:[PDH_newResCount]
jz done
mov cx, es:[PDH_count]
mov si, offset PDH_resources
startLoop:
mov ax, es:[si].PRE_id
cmp ax, es:[PDH_origResCount]
jb next
shl ax
mov di, dx
add di, ax
mov ax, {word} es:[si].PRE_heapFlags
mov ss:[di], ax
next:
add si, size PatchedResourceEntry
loop startLoop
done:
.leave
ret
GeodePatchReadAllocationFlags endp
endif ; USE_BUG_PATCHES
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
GeodeGetPatchedResourceSize
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Return the proper resource size of a resource, if it's
patched.
CALLED BY: AllocateResource
PASS: ds - core block
si - resource number * 2
ax - size of resource
RETURN: ax - updated, if resource is patched
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
chrisb 3/31/94 Initial version.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
GeodeGetPatchedResourceSize proc far
uses cx,si,es,di
.enter
EC < call ECCheckCoreBlockDS >
shr si ; Resource number.
if USE_BUG_PATCHES
tryGeneralPatches::
tst ds:[GH_generalPatchData]
jz tryLanguagePatches ; No general patches.
call GeodeGetGeneralPatchBlock
; es = Patch data segment.
mov cx, es:[PDH_count]
mov di, offset PDH_resources
startLoopGeneral:
cmp si, es:[di].PRE_id
je found
jb tryLanguagePatches ; Since resources are stored
; in order.
add di, size PatchedResourceEntry
loop startLoopGeneral
endif
tryLanguagePatches::
if MULTI_LANGUAGE
tst ds:[GH_languagePatchData]
jz done ; No language patches.
mov bx, ds:[GH_languagePatchData]
call MemDerefES
mov cx, es:[PDH_count]
mov di, offset PDH_resources
startLoopLanguage:
cmp si, es:[di].PRE_id
je found
jb done ; Since resources are stored
; in order.
add di, size PatchedResourceEntry
loop startLoopLanguage
endif
done:
.leave
ret
found:
add ax, es:[di].PRE_resourceSizeDiff
jmp done
GeodeGetPatchedResourceSize endp
if USE_BUG_PATCHES
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
GeodePatchReAllocCoreBlock
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Reallocate the core block larger to provide room for
additional entry points and resources, if necessary.
CALLED BY: GeodeModifyCoreBlock, LoadGeodeAfterFileOpen,
PASS: ds - segment of core block
es - kdata
RETURN: ds - segment of core block (may have moved)
DESTROYED: bx, dx
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
chrisb 2/ 3/94 Initial version.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
GeodePatchReAllocCoreBlock proc far
uses es
.enter
EC < call ECCheckCoreBlockDS >
EC < call ECCheckDGroupES >
; Fetch original size of core block.
LoadVarSeg es, ax
mov ax, es:[bx].HM_size
mov cl, 4
shl ax, cl
; Get the patch data.
call GeodeGetGeneralPatchBlock
; es = Patch data segment.
; Will the core block be patched? (It would be the first entry,
; since resources are stored in order.)
tst es:[PDH_resources].PRE_id
jnz done ; No core block changes.
; See if core block size will change with the patch.
mov cx, es:[PDH_resources].PRE_resourceSizeDiff
jcxz done ; No change in # of resources.
; Reallocate the core block to the new size.
add ax, cx
mov bx, ds:[GH_geodeHandle]
mov ch, mask HAF_ZERO_INIT or mask HAF_NO_ERR
call MemReAlloc
mov ds, ax
done:
.leave
ret
GeodePatchReAllocCoreBlock endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
GeodePatchCoreBlock
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Apply patch to the core block (if patch exists), and
recalculate pointers to geode tables if resources were
added.
CALLED BY: InitResources (for new, non-XIP geodes),
GeodeModifyCoreBlock (for all other geodes)
PASS: ds - segment of core block
RETURN: nothing
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
chrisb 3/30/94 Initial version.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
GeodePatchCoreBlock proc far
uses ax,dx,di,es
.enter
EC < call ECCheckCoreBlockDS >
mov ax, ds
mov dx, ds:[GH_geodeHandle]
; Does core block have a patch? (It would be the first entry.)
call GeodeGetGeneralPatchBlock
; es = Patch data segment.
tst es:[PDH_resources].PRE_id
jnz done ; No core block patch.
; Apply the patch.
mov di, offset PDH_resources
call GeodePatchResourceFar
; Recalculate the pointers to the resource position table,
; relocation table size table, and extra library table.
mov ax, es:[PDH_newResCount]
shl ax
add ds:[GH_resPosOff], ax
add ds:[GH_resRelocOff], ax
add ds:[GH_extraLibOffset], ax
done:
.leave
ret
GeodePatchCoreBlock endp
endif ; USE_BUG_PATCHES
endif ; USE_PATCHES
GLoad ends
|
; A151312: Number of walks within N^2 (the first quadrant of Z^2) starting at (0,0) and consisting of n steps taken from {(-1, -1), (-1, 1), (-1, 0), (1, -1), (1, 0), (1, 1)}.
; Submitted by Jon Maiga
; 1,2,10,39,210,960,5340,26250,148610,761796,4360356,22971102,132469260,711426144,4124979144,22471772895,130833575730,720642479700,4209268283220,23389011317958,136971640993044,766537623135648,4498668129173400,25325478605719656,148897823229533196,842422760884567800,4960479753255506200,28185025652469706500,166181330296429525800,947717688210266188800,5594206220961029028720,32006191098828060403290,189116039149216206347250,1085065084174767746986980,6417040504431808285885620,36910967241012343509133950
mov $1,1
mov $2,1
mov $3,$0
mov $4,2
lpb $3
mul $1,$3
sub $3,1
cmp $4,2
add $5,$4
div $1,$5
add $2,$1
add $4,2
lpe
mul $2,$1
mov $0,$2
|
; /* aes_asm.asm
; *
; * Copyright (C) 2006-2016 wolfSSL Inc.
; *
; * This file is part of wolfssl. (formerly known as CyaSSL)
; *
; * wolfSSL is free software; you can redistribute it and/or modify
; * it under the term of the GNU General Public License as published by
; * the Free Software Foundation/either version 2 of the License, or
; * (at your option) any later version.
; *
; * wolfSSL is distributed in the hope that it will be useful,
; * but WITHOUT ANY WARRANTY; without even the implied warranty of
; * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; * GNU General Public License for more details.
; *
; * You should have received a copy of the GNU General Public License
; * along with this program; if not, write to the Free Software
; * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
; */
;
;
; /* See Intel Advanced Encryption Standard (AES) Instructions Set White Paper
; * by Israel, Intel Mobility Group Development Center, Israel Shay Gueron
; */
;
; /* This file is in intel asm syntax, see .s for at&t syntax */
;
fips_version = 0
IFDEF HAVE_FIPS
fips_version = 1
IFDEF HAVE_FIPS_VERSION
fips_version = HAVE_FIPS_VERSION
ENDIF
ENDIF
IF fips_version GE 2
fipsAh SEGMENT ALIAS(".fipsA$h") 'CODE'
ELSE
_text SEGMENT
ENDIF
; /*
; AES_CBC_encrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,char ivec+16
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
AES_CBC_encrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8
;# parameter 6: r9d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8,[rsp+40]
mov r9d,[rsp+48]
mov r10,rcx
shr rcx,4
shl r10,60
je NO_PARTS
add rcx,1
NO_PARTS:
sub rsi,16
movdqa xmm1,[rdx]
LOOP_1:
pxor xmm1,[rdi]
pxor xmm1,[r8]
add rsi,16
add rdi,16
cmp r9d,12
aesenc xmm1,16[r8]
aesenc xmm1,32[r8]
aesenc xmm1,48[r8]
aesenc xmm1,64[r8]
aesenc xmm1,80[r8]
aesenc xmm1,96[r8]
aesenc xmm1,112[r8]
aesenc xmm1,128[r8]
aesenc xmm1,144[r8]
movdqa xmm2,160[r8]
jb LAST
cmp r9d,14
aesenc xmm1,160[r8]
aesenc xmm1,176[r8]
movdqa xmm2,192[r8]
jb LAST
aesenc xmm1,192[r8]
aesenc xmm1,208[r8]
movdqa xmm2,224[r8]
LAST:
dec rcx
aesenclast xmm1,xmm2
movdqu [rsi],xmm1
jne LOOP_1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
AES_CBC_encrypt ENDP
; void AES_CBC_decrypt_by4(const unsigned char* in,
; unsigned char* out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char* KS,
; int nr)
AES_CBC_decrypt_by4 PROC
; parameter 1: rdi
; parameter 2: rsi
; parameter 3: rdx
; parameter 4: rcx
; parameter 5: r8
; parameter 6: r9d
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx,r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+8*16 ; 8 = align stack , 8 xmm6-12,15 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm15
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_4
add rcx, 1
DNO_PARTS_4:
mov r10, rcx
shl r10, 62
shr r10, 62
shr rcx, 2
movdqu xmm5, [rdx]
je DREMAINDER_4
sub rsi, 64
DLOOP_4:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqa xmm6, xmm1
movdqa xmm7, xmm2
movdqa xmm8, xmm3
movdqa xmm15, xmm4
movdqa xmm9, [r8]
movdqa xmm10, 16[r8]
movdqa xmm11, 32[r8]
movdqa xmm12, 48[r8]
pxor xmm1, xmm9
pxor xmm2, xmm9
pxor xmm3, xmm9
pxor xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
movdqa xmm9, 64[r8]
movdqa xmm10, 80[r8]
movdqa xmm11, 96[r8]
movdqa xmm12, 112[r8]
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
movdqa xmm9, 128[r8]
movdqa xmm10, 144[r8]
movdqa xmm11, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
jb DLAST_4
movdqa xmm9, 160[r8]
movdqa xmm10, 176[r8]
movdqa xmm11, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
jb DLAST_4
movdqa xmm9, 192[r8]
movdqa xmm10, 208[r8]
movdqa xmm11, 224[r8]
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
DLAST_4:
add rdi, 64
add rsi, 64
dec rcx
aesdeclast xmm1, xmm11
aesdeclast xmm2, xmm11
aesdeclast xmm3, xmm11
aesdeclast xmm4, xmm11
pxor xmm1, xmm5
pxor xmm2, xmm6
pxor xmm3, xmm7
pxor xmm4, xmm8
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqa xmm5, xmm15
jne DLOOP_4
add rsi, 64
DREMAINDER_4:
cmp r10, 0
je DEND_4
DLOOP_4_2:
movdqu xmm1, [rdi]
movdqa xmm15, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_4_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_4_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_4_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm5
movdqa xmm5, xmm15
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_4_2
DEND_4:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm15, [rsp+112]
add rsp, 8+8*16 ; 8 = align stack , 8 xmm6-12,15 16 bytes each
ret
AES_CBC_decrypt_by4 ENDP
; void AES_CBC_decrypt_by6(const unsigned char *in,
; unsigned char *out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char *KS,
; int nr)
AES_CBC_decrypt_by6 PROC
; parameter 1: rdi - in
; parameter 2: rsi - out
; parameter 3: rdx - ivec
; parameter 4: rcx - length
; parameter 5: r8 - KS
; parameter 6: r9d - nr
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx, r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+9*16 ; 8 = align stack , 9 xmm6-14 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm13
movdqa [rsp+128], xmm14
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_6
add rcx, 1
DNO_PARTS_6:
mov r12, rax
mov r13, rdx
mov r14, rbx
mov rdx, 0
mov rax, rcx
mov rbx, 6
div rbx
mov rcx, rax
mov r10, rdx
mov rax, r12
mov rdx, r13
mov rbx, r14
cmp rcx, 0
movdqu xmm7, [rdx]
je DREMAINDER_6
sub rsi, 96
DLOOP_6:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqu xmm5, 64[rdi]
movdqu xmm6, 80[rdi]
movdqa xmm8, [r8]
movdqa xmm9, 16[r8]
movdqa xmm10, 32[r8]
movdqa xmm11, 48[r8]
pxor xmm1, xmm8
pxor xmm2, xmm8
pxor xmm3, xmm8
pxor xmm4, xmm8
pxor xmm5, xmm8
pxor xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
movdqa xmm8, 64[r8]
movdqa xmm9, 80[r8]
movdqa xmm10, 96[r8]
movdqa xmm11, 112[r8]
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
movdqa xmm8, 128[r8]
movdqa xmm9, 144[r8]
movdqa xmm10, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
jb DLAST_6
movdqa xmm8, 160[r8]
movdqa xmm9, 176[r8]
movdqa xmm10, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
jb DLAST_6
movdqa xmm8, 192[r8]
movdqa xmm9, 208[r8]
movdqa xmm10, 224[r8]
aesdec xmm1, xmm8
aesdec xmm2, xmm8
aesdec xmm3, xmm8
aesdec xmm4, xmm8
aesdec xmm5, xmm8
aesdec xmm6, xmm8
aesdec xmm1, xmm9
aesdec xmm2, xmm9
aesdec xmm3, xmm9
aesdec xmm4, xmm9
aesdec xmm5, xmm9
aesdec xmm6, xmm9
DLAST_6:
add rsi, 96
aesdeclast xmm1, xmm10
aesdeclast xmm2, xmm10
aesdeclast xmm3, xmm10
aesdeclast xmm4, xmm10
aesdeclast xmm5, xmm10
aesdeclast xmm6, xmm10
movdqu xmm8, [rdi]
movdqu xmm9, 16[rdi]
movdqu xmm10, 32[rdi]
movdqu xmm11, 48[rdi]
movdqu xmm12, 64[rdi]
movdqu xmm13, 80[rdi]
pxor xmm1, xmm7
pxor xmm2, xmm8
pxor xmm3, xmm9
pxor xmm4, xmm10
pxor xmm5, xmm11
pxor xmm6, xmm12
movdqu xmm7, xmm13
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqu 64[rsi], xmm5
movdqu 80[rsi], xmm6
add rdi, 96
dec rcx
jne DLOOP_6
add rsi, 96
DREMAINDER_6:
cmp r10, 0
je DEND_6
DLOOP_6_2:
movdqu xmm1, [rdi]
movdqa xmm10, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_6_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_6_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_6_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm7
movdqa xmm7, xmm10
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_6_2
DEND_6:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm13, [rsp+112]
movdqa xmm14, [rsp+128]
add rsp, 8+9*16 ; 8 = align stack , 9 xmm6-14 16 bytes each
ret
AES_CBC_decrypt_by6 ENDP
; void AES_CBC_decrypt_by8(const unsigned char *in,
; unsigned char *out,
; unsigned char ivec[16],
; unsigned long length,
; const unsigned char *KS,
; int nr)
AES_CBC_decrypt_by8 PROC
; parameter 1: rdi - in
; parameter 2: rsi - out
; parameter 3: rdx - ivec
; parameter 4: rcx - length
; parameter 5: r8 - KS
; parameter 6: r9d - nr
; save rdi and rsi to rax and r11, restore before ret
mov rax, rdi
mov r11, rsi
; convert to what we had for att&t convention
mov rdi, rcx
mov rsi, rdx
mov rdx, r8
mov rcx,r9
mov r8, [rsp+40]
mov r9d, [rsp+48]
; on microsoft xmm6-xmm15 are non volatile,
; let's save on stack and restore at end
sub rsp, 8+8*16 ; 8 = align stack , 8 xmm6-13 16 bytes each
movdqa [rsp+0], xmm6
movdqa [rsp+16], xmm7
movdqa [rsp+32], xmm8
movdqa [rsp+48], xmm9
movdqa [rsp+64], xmm10
movdqa [rsp+80], xmm11
movdqa [rsp+96], xmm12
movdqa [rsp+112], xmm13
; back to our original code, more or less
mov r10, rcx
shr rcx, 4
shl r10, 60
je DNO_PARTS_8
add rcx, 1
DNO_PARTS_8:
mov r10, rcx
shl r10, 61
shr r10, 61
shr rcx, 3
movdqu xmm9, [rdx]
je DREMAINDER_8
sub rsi, 128
DLOOP_8:
movdqu xmm1, [rdi]
movdqu xmm2, 16[rdi]
movdqu xmm3, 32[rdi]
movdqu xmm4, 48[rdi]
movdqu xmm5, 64[rdi]
movdqu xmm6, 80[rdi]
movdqu xmm7, 96[rdi]
movdqu xmm8, 112[rdi]
movdqa xmm10, [r8]
movdqa xmm11, 16[r8]
movdqa xmm12, 32[r8]
movdqa xmm13, 48[r8]
pxor xmm1, xmm10
pxor xmm2, xmm10
pxor xmm3, xmm10
pxor xmm4, xmm10
pxor xmm5, xmm10
pxor xmm6, xmm10
pxor xmm7, xmm10
pxor xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
aesdec xmm5, xmm12
aesdec xmm6, xmm12
aesdec xmm7, xmm12
aesdec xmm8, xmm12
aesdec xmm1, xmm13
aesdec xmm2, xmm13
aesdec xmm3, xmm13
aesdec xmm4, xmm13
aesdec xmm5, xmm13
aesdec xmm6, xmm13
aesdec xmm7, xmm13
aesdec xmm8, xmm13
movdqa xmm10, 64[r8]
movdqa xmm11, 80[r8]
movdqa xmm12, 96[r8]
movdqa xmm13, 112[r8]
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
aesdec xmm1, xmm12
aesdec xmm2, xmm12
aesdec xmm3, xmm12
aesdec xmm4, xmm12
aesdec xmm5, xmm12
aesdec xmm6, xmm12
aesdec xmm7, xmm12
aesdec xmm8, xmm12
aesdec xmm1, xmm13
aesdec xmm2, xmm13
aesdec xmm3, xmm13
aesdec xmm4, xmm13
aesdec xmm5, xmm13
aesdec xmm6, xmm13
aesdec xmm7, xmm13
aesdec xmm8, xmm13
movdqa xmm10, 128[r8]
movdqa xmm11, 144[r8]
movdqa xmm12, 160[r8]
cmp r9d, 12
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
jb DLAST_8
movdqa xmm10, 160[r8]
movdqa xmm11, 176[r8]
movdqa xmm12, 192[r8]
cmp r9d, 14
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
jb DLAST_8
movdqa xmm10, 192[r8]
movdqa xmm11, 208[r8]
movdqa xmm12, 224[r8]
aesdec xmm1, xmm10
aesdec xmm2, xmm10
aesdec xmm3, xmm10
aesdec xmm4, xmm10
aesdec xmm5, xmm10
aesdec xmm6, xmm10
aesdec xmm7, xmm10
aesdec xmm8, xmm10
aesdec xmm1, xmm11
aesdec xmm2, xmm11
aesdec xmm3, xmm11
aesdec xmm4, xmm11
aesdec xmm5, xmm11
aesdec xmm6, xmm11
aesdec xmm7, xmm11
aesdec xmm8, xmm11
DLAST_8:
add rsi, 128
aesdeclast xmm1, xmm12
aesdeclast xmm2, xmm12
aesdeclast xmm3, xmm12
aesdeclast xmm4, xmm12
aesdeclast xmm5, xmm12
aesdeclast xmm6, xmm12
aesdeclast xmm7, xmm12
aesdeclast xmm8, xmm12
movdqu xmm10, [rdi]
movdqu xmm11, 16[rdi]
movdqu xmm12, 32[rdi]
movdqu xmm13, 48[rdi]
pxor xmm1, xmm9
pxor xmm2, xmm10
pxor xmm3, xmm11
pxor xmm4, xmm12
pxor xmm5, xmm13
movdqu xmm10, 64[rdi]
movdqu xmm11, 80[rdi]
movdqu xmm12, 96[rdi]
movdqu xmm9, 112[rdi]
pxor xmm6, xmm10
pxor xmm7, xmm11
pxor xmm8, xmm12
movdqu [rsi], xmm1
movdqu 16[rsi], xmm2
movdqu 32[rsi], xmm3
movdqu 48[rsi], xmm4
movdqu 64[rsi], xmm5
movdqu 80[rsi], xmm6
movdqu 96[rsi], xmm7
movdqu 112[rsi], xmm8
add rdi, 128
dec rcx
jne DLOOP_8
add rsi, 128
DREMAINDER_8:
cmp r10, 0
je DEND_8
DLOOP_8_2:
movdqu xmm1, [rdi]
movdqa xmm10, xmm1
add rdi, 16
pxor xmm1, [r8]
movdqu xmm2, 160[r8]
cmp r9d, 12
aesdec xmm1, 16[r8]
aesdec xmm1, 32[r8]
aesdec xmm1, 48[r8]
aesdec xmm1, 64[r8]
aesdec xmm1, 80[r8]
aesdec xmm1, 96[r8]
aesdec xmm1, 112[r8]
aesdec xmm1, 128[r8]
aesdec xmm1, 144[r8]
jb DLAST_8_2
movdqu xmm2, 192[r8]
cmp r9d, 14
aesdec xmm1, 160[r8]
aesdec xmm1, 176[r8]
jb DLAST_8_2
movdqu xmm2, 224[r8]
aesdec xmm1, 192[r8]
aesdec xmm1, 208[r8]
DLAST_8_2:
aesdeclast xmm1, xmm2
pxor xmm1, xmm9
movdqa xmm9, xmm10
movdqu [rsi], xmm1
add rsi, 16
dec r10
jne DLOOP_8_2
DEND_8:
; restore non volatile rdi,rsi
mov rdi, rax
mov rsi, r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
movdqa xmm7, [rsp+16]
movdqa xmm8, [rsp+32]
movdqa xmm9, [rsp+48]
movdqa xmm10, [rsp+64]
movdqa xmm11, [rsp+80]
movdqa xmm12, [rsp+96]
movdqa xmm13, [rsp+112]
add rsp, 8+8*16 ; 8 = align stack , 8 xmm6-13 16 bytes each
ret
AES_CBC_decrypt_by8 ENDP
; /*
; AES_ECB_encrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
; . globl AES_ECB_encrypt
AES_ECB_encrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8d,[rsp+40]
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+4*16 ; 8 = align stack , 4 xmm9-12, 16 bytes each
movdqa [rsp+0], xmm9
movdqa [rsp+16], xmm10
movdqa [rsp+32], xmm11
movdqa [rsp+48], xmm12
mov r10,rdx
shr rdx,4
shl r10,60
je EECB_NO_PARTS_4
add rdx,1
EECB_NO_PARTS_4:
mov r10,rdx
shl r10,62
shr r10,62
shr rdx,2
je EECB_REMAINDER_4
sub rsi,64
EECB_LOOP_4:
movdqu xmm1,[rdi]
movdqu xmm2,16[rdi]
movdqu xmm3,32[rdi]
movdqu xmm4,48[rdi]
movdqa xmm9,[rcx]
movdqa xmm10,16[rcx]
movdqa xmm11,32[rcx]
movdqa xmm12,48[rcx]
pxor xmm1,xmm9
pxor xmm2,xmm9
pxor xmm3,xmm9
pxor xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
aesenc xmm1,xmm11
aesenc xmm2,xmm11
aesenc xmm3,xmm11
aesenc xmm4,xmm11
aesenc xmm1,xmm12
aesenc xmm2,xmm12
aesenc xmm3,xmm12
aesenc xmm4,xmm12
movdqa xmm9,64[rcx]
movdqa xmm10,80[rcx]
movdqa xmm11,96[rcx]
movdqa xmm12,112[rcx]
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
aesenc xmm1,xmm11
aesenc xmm2,xmm11
aesenc xmm3,xmm11
aesenc xmm4,xmm11
aesenc xmm1,xmm12
aesenc xmm2,xmm12
aesenc xmm3,xmm12
aesenc xmm4,xmm12
movdqa xmm9,128[rcx]
movdqa xmm10,144[rcx]
movdqa xmm11,160[rcx]
cmp r8d,12
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
jb EECB_LAST_4
movdqa xmm9,160[rcx]
movdqa xmm10,176[rcx]
movdqa xmm11,192[rcx]
cmp r8d,14
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
jb EECB_LAST_4
movdqa xmm9,192[rcx]
movdqa xmm10,208[rcx]
movdqa xmm11,224[rcx]
aesenc xmm1,xmm9
aesenc xmm2,xmm9
aesenc xmm3,xmm9
aesenc xmm4,xmm9
aesenc xmm1,xmm10
aesenc xmm2,xmm10
aesenc xmm3,xmm10
aesenc xmm4,xmm10
EECB_LAST_4:
add rdi,64
add rsi,64
dec rdx
aesenclast xmm1,xmm11
aesenclast xmm2,xmm11
aesenclast xmm3,xmm11
aesenclast xmm4,xmm11
movdqu [rsi],xmm1
movdqu 16[rsi],xmm2
movdqu 32[rsi],xmm3
movdqu 48[rsi],xmm4
jne EECB_LOOP_4
add rsi,64
EECB_REMAINDER_4:
cmp r10,0
je EECB_END_4
EECB_LOOP_4_2:
movdqu xmm1,[rdi]
add rdi,16
pxor xmm1,[rcx]
movdqu xmm2,160[rcx]
aesenc xmm1,16[rcx]
aesenc xmm1,32[rcx]
aesenc xmm1,48[rcx]
aesenc xmm1,64[rcx]
aesenc xmm1,80[rcx]
aesenc xmm1,96[rcx]
aesenc xmm1,112[rcx]
aesenc xmm1,128[rcx]
aesenc xmm1,144[rcx]
cmp r8d,12
jb EECB_LAST_4_2
movdqu xmm2,192[rcx]
aesenc xmm1,160[rcx]
aesenc xmm1,176[rcx]
cmp r8d,14
jb EECB_LAST_4_2
movdqu xmm2,224[rcx]
aesenc xmm1,192[rcx]
aesenc xmm1,208[rcx]
EECB_LAST_4_2:
aesenclast xmm1,xmm2
movdqu [rsi],xmm1
add rsi,16
dec r10
jne EECB_LOOP_4_2
EECB_END_4:
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm9, [rsp+0]
movdqa xmm10, [rsp+16]
movdqa xmm11, [rsp+32]
movdqa xmm12, [rsp+48]
add rsp,8+4*16 ; 8 = align stack , 4 xmm9-12 16 bytes each
ret
AES_ECB_encrypt ENDP
; /*
; AES_ECB_decrypt[const ,unsigned char*in
; unsigned ,char*out
; unsigned ,long length
; const ,unsigned char*KS
; int nr]
; */
; . globl AES_ECB_decrypt
AES_ECB_decrypt PROC
;# parameter 1: rdi
;# parameter 2: rsi
;# parameter 3: rdx
;# parameter 4: rcx
;# parameter 5: r8d
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov rdx,r8
mov rcx,r9
mov r8d,[rsp+40]
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+4*16 ; 8 = align stack , 4 xmm9-12, 16 bytes each
movdqa [rsp+0], xmm9
movdqa [rsp+16], xmm10
movdqa [rsp+32], xmm11
movdqa [rsp+48], xmm12
mov r10,rdx
shr rdx,4
shl r10,60
je DECB_NO_PARTS_4
add rdx,1
DECB_NO_PARTS_4:
mov r10,rdx
shl r10,62
shr r10,62
shr rdx,2
je DECB_REMAINDER_4
sub rsi,64
DECB_LOOP_4:
movdqu xmm1,[rdi]
movdqu xmm2,16[rdi]
movdqu xmm3,32[rdi]
movdqu xmm4,48[rdi]
movdqa xmm9,[rcx]
movdqa xmm10,16[rcx]
movdqa xmm11,32[rcx]
movdqa xmm12,48[rcx]
pxor xmm1,xmm9
pxor xmm2,xmm9
pxor xmm3,xmm9
pxor xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
aesdec xmm1,xmm11
aesdec xmm2,xmm11
aesdec xmm3,xmm11
aesdec xmm4,xmm11
aesdec xmm1,xmm12
aesdec xmm2,xmm12
aesdec xmm3,xmm12
aesdec xmm4,xmm12
movdqa xmm9,64[rcx]
movdqa xmm10,80[rcx]
movdqa xmm11,96[rcx]
movdqa xmm12,112[rcx]
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
aesdec xmm1,xmm11
aesdec xmm2,xmm11
aesdec xmm3,xmm11
aesdec xmm4,xmm11
aesdec xmm1,xmm12
aesdec xmm2,xmm12
aesdec xmm3,xmm12
aesdec xmm4,xmm12
movdqa xmm9,128[rcx]
movdqa xmm10,144[rcx]
movdqa xmm11,160[rcx]
cmp r8d,12
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
jb DECB_LAST_4
movdqa xmm9,160[rcx]
movdqa xmm10,176[rcx]
movdqa xmm11,192[rcx]
cmp r8d,14
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
jb DECB_LAST_4
movdqa xmm9,192[rcx]
movdqa xmm10,208[rcx]
movdqa xmm11,224[rcx]
aesdec xmm1,xmm9
aesdec xmm2,xmm9
aesdec xmm3,xmm9
aesdec xmm4,xmm9
aesdec xmm1,xmm10
aesdec xmm2,xmm10
aesdec xmm3,xmm10
aesdec xmm4,xmm10
DECB_LAST_4:
add rdi,64
add rsi,64
dec rdx
aesdeclast xmm1,xmm11
aesdeclast xmm2,xmm11
aesdeclast xmm3,xmm11
aesdeclast xmm4,xmm11
movdqu [rsi],xmm1
movdqu 16[rsi],xmm2
movdqu 32[rsi],xmm3
movdqu 48[rsi],xmm4
jne DECB_LOOP_4
add rsi,64
DECB_REMAINDER_4:
cmp r10,0
je DECB_END_4
DECB_LOOP_4_2:
movdqu xmm1,[rdi]
add rdi,16
pxor xmm1,[rcx]
movdqu xmm2,160[rcx]
cmp r8d,12
aesdec xmm1,16[rcx]
aesdec xmm1,32[rcx]
aesdec xmm1,48[rcx]
aesdec xmm1,64[rcx]
aesdec xmm1,80[rcx]
aesdec xmm1,96[rcx]
aesdec xmm1,112[rcx]
aesdec xmm1,128[rcx]
aesdec xmm1,144[rcx]
jb DECB_LAST_4_2
cmp r8d,14
movdqu xmm2,192[rcx]
aesdec xmm1,160[rcx]
aesdec xmm1,176[rcx]
jb DECB_LAST_4_2
movdqu xmm2,224[rcx]
aesdec xmm1,192[rcx]
aesdec xmm1,208[rcx]
DECB_LAST_4_2:
aesdeclast xmm1,xmm2
movdqu [rsi],xmm1
add rsi,16
dec r10
jne DECB_LOOP_4_2
DECB_END_4:
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm9, [rsp+0]
movdqa xmm10, [rsp+16]
movdqa xmm11, [rsp+32]
movdqa xmm12, [rsp+48]
add rsp,8+4*16 ; 8 = align stack , 4 xmm9-12 16 bytes each
ret
AES_ECB_decrypt ENDP
; /*
; void ,AES_128_Key_Expansion[const unsigned char*userkey
; unsigned char*key_schedule]/
; */
; . align 16,0x90
; . globl AES_128_Key_Expansion
AES_128_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
mov dword ptr 240[rsi],10
movdqu xmm1,[rdi]
movdqa [rsi],xmm1
ASSISTS:
aeskeygenassist xmm2,xmm1,1
call PREPARE_ROUNDKEY_128
movdqa 16[rsi],xmm1
aeskeygenassist xmm2,xmm1,2
call PREPARE_ROUNDKEY_128
movdqa 32[rsi],xmm1
aeskeygenassist xmm2,xmm1,4
call PREPARE_ROUNDKEY_128
movdqa 48[rsi],xmm1
aeskeygenassist xmm2,xmm1,8
call PREPARE_ROUNDKEY_128
movdqa 64[rsi],xmm1
aeskeygenassist xmm2,xmm1,16
call PREPARE_ROUNDKEY_128
movdqa 80[rsi],xmm1
aeskeygenassist xmm2,xmm1,32
call PREPARE_ROUNDKEY_128
movdqa 96[rsi],xmm1
aeskeygenassist xmm2,xmm1,64
call PREPARE_ROUNDKEY_128
movdqa 112[rsi],xmm1
aeskeygenassist xmm2,xmm1,80h
call PREPARE_ROUNDKEY_128
movdqa 128[rsi],xmm1
aeskeygenassist xmm2,xmm1,1bh
call PREPARE_ROUNDKEY_128
movdqa 144[rsi],xmm1
aeskeygenassist xmm2,xmm1,36h
call PREPARE_ROUNDKEY_128
movdqa 160[rsi],xmm1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
PREPARE_ROUNDKEY_128:
pshufd xmm2,xmm2,255
movdqa xmm3,xmm1
pslldq xmm3,4
pxor xmm1,xmm3
pslldq xmm3,4
pxor xmm1,xmm3
pslldq xmm3,4
pxor xmm1,xmm3
pxor xmm1,xmm2
ret
AES_128_Key_Expansion ENDP
; /*
; void ,AES_192_Key_Expansion[const unsigned char*userkey
; unsigned char*key]
; */
; . globl AES_192_Key_Expansion
AES_192_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
; on microsoft xmm6-xmm15 are non volaitle, let's save on stack and restore at end
sub rsp,8+1*16 ; 8 = align stack , 1 xmm6, 16 bytes each
movdqa [rsp+0], xmm6
movdqu xmm1,[rdi]
movq xmm3,qword ptr 16[rdi]
movdqa [rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,1h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 16[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 32[rsi],xmm6
aeskeygenassist xmm2,xmm3,2h
call PREPARE_ROUNDKEY_192
movdqa 48[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,4h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 64[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 80[rsi],xmm6
aeskeygenassist xmm2,xmm3,8h
call PREPARE_ROUNDKEY_192
movdqa 96[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,10h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 112[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 128[rsi],xmm6
aeskeygenassist xmm2,xmm3,20h
call PREPARE_ROUNDKEY_192
movdqa 144[rsi],xmm1
movdqa xmm5,xmm3
aeskeygenassist xmm2,xmm3,40h
call PREPARE_ROUNDKEY_192
shufpd xmm5,xmm1,0
movdqa 160[rsi],xmm5
movdqa xmm6,xmm1
shufpd xmm6,xmm3,1
movdqa 176[rsi],xmm6
aeskeygenassist xmm2,xmm3,80h
call PREPARE_ROUNDKEY_192
movdqa 192[rsi],xmm1
movdqa 208[rsi],xmm3
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
; restore non volatile xmms from stack
movdqa xmm6, [rsp+0]
add rsp,8+1*16 ; 8 = align stack , 1 xmm6 16 bytes each
ret
PREPARE_ROUNDKEY_192:
pshufd xmm2,xmm2,55h
movdqu xmm4,xmm1
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pxor xmm1,xmm2
pshufd xmm2,xmm1,0ffh
movdqu xmm4,xmm3
pslldq xmm4,4
pxor xmm3,xmm4
pxor xmm3,xmm2
ret
AES_192_Key_Expansion ENDP
; /*
; void ,AES_256_Key_Expansion[const unsigned char*userkey
; unsigned char*key]
; */
; . globl AES_256_Key_Expansion
AES_256_Key_Expansion PROC
;# parameter 1: rdi
;# parameter 2: rsi
; save rdi and rsi to rax and r11, restore before ret
mov rax,rdi
mov r11,rsi
; convert to what we had for att&t convention
mov rdi,rcx
mov rsi,rdx
movdqu xmm1,[rdi]
movdqu xmm3,16[rdi]
movdqa [rsi],xmm1
movdqa 16[rsi],xmm3
aeskeygenassist xmm2,xmm3,1h
call MAKE_RK256_a
movdqa 32[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 48[rsi],xmm3
aeskeygenassist xmm2,xmm3,2h
call MAKE_RK256_a
movdqa 64[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 80[rsi],xmm3
aeskeygenassist xmm2,xmm3,4h
call MAKE_RK256_a
movdqa 96[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 112[rsi],xmm3
aeskeygenassist xmm2,xmm3,8h
call MAKE_RK256_a
movdqa 128[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 144[rsi],xmm3
aeskeygenassist xmm2,xmm3,10h
call MAKE_RK256_a
movdqa 160[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 176[rsi],xmm3
aeskeygenassist xmm2,xmm3,20h
call MAKE_RK256_a
movdqa 192[rsi],xmm1
aeskeygenassist xmm2,xmm1,0h
call MAKE_RK256_b
movdqa 208[rsi],xmm3
aeskeygenassist xmm2,xmm3,40h
call MAKE_RK256_a
movdqa 224[rsi],xmm1
; restore non volatile rdi,rsi
mov rdi,rax
mov rsi,r11
ret
AES_256_Key_Expansion ENDP
MAKE_RK256_a:
pshufd xmm2,xmm2,0ffh
movdqa xmm4,xmm1
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pslldq xmm4,4
pxor xmm1,xmm4
pxor xmm1,xmm2
ret
MAKE_RK256_b:
pshufd xmm2,xmm2,0aah
movdqa xmm4,xmm3
pslldq xmm4,4
pxor xmm3,xmm4
pslldq xmm4,4
pxor xmm3,xmm4
pslldq xmm4,4
pxor xmm3,xmm4
pxor xmm3,xmm2
ret
IF fips_version GE 2
fipsAh ENDS
ELSE
_text ENDS
ENDIF
END
|
;*
;* CW : Character Windows Drivers
;*
;* fx_tandy.asm : Tandy 1000 DOS 3 LINKED-IN keyboard driver
;* DOES NOT include kbd_code
;* has data in application's data segment
;*****************************************************************************
include kbd_head.inc
include fxdrv.inc
include kbd3.inc
;* special stuff for DOS 3 driver
include scan3.inc
include tsr3.inc
include bios.inc
include kbd_data.inc
;*****************************************************************************
;* * Special DATA
include fx_data.asm
;*****************************************************************************
sBegin DRV
assumes CS,DRV
assumes ds,NOTHING
assumes ss,NOTHING
;* * There is no low memory structure for the linked driver
lpwDataKbd EQU THIS DWORD
OFF_lpwDataKbd DW dataOffset rgwDataKbd
SEG_lpwDataKbd DW SEG DGROUP
;STD_NUMPAD = 1 ; normal DOS3 numpad handling (eats '5')
TANDY_1000 = 1 ; special key interrupt handling
;*****************************************************************************
;* * keyboard tables go here
include tantable.asm ;* Scan code tables
include kbd_ibm.asm ;* IBM helpers etc
;*****************************************************************************
;* * Main routines
include keyacc3.asm ;* accessory routines
include keyint3.asm ;* interrupt
include tanxlat.asm ;* polling translations
;*****************************************************************************
include kbd_std.asm ;* standard init/term
;*****************************************************************************
include kbd_tail.asm ;* tail file
;*****************************************************************************
END
|
LHLD C050
XCHG
LHLD C052
MVI C,00
DAD D
JNC AHEAD
INR C
AHEAD: SHLD C054
MOV A,C
STA C056
HLT
ORG 0
# DB 45H,A6H,23H,9BH
|
#ifndef _PROBLEM_HH_
#define _PROBLEM_HH_
#include <Eigen/Sparse>
#include <Eigen/Dense>
#include <fstream>
#include <sstream>
#include <iostream>
#include <unordered_map>
typedef double val;
typedef Eigen::SparseMatrix<val, Eigen::RowMajor> sp_mat;
typedef Eigen::Matrix<val, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> mat;
typedef Eigen::Triplet<val> triplet;
class Entity {
public:
int n; // number of training examples
sp_mat A; // intrinsic graph structure among entities
std::unordered_map<int, std::string> id_of; // given the instance index, return id
std::unordered_map<std::string, int> index_of; // given the instance id, return index
/*
* load the entity graph from sparse representation
*/
Entity(const char* filename) {
assert(loadSparseGraph(filename));
}
/*
* @FORMAT
* As in LibSVM, each line of the input file should consist of
* `instance_id<string> feature_1<int>:value_1<val> feature_2 value_2`
*
* A symmetric k-NN graph will be constructed afterwards
*
* Note the full kernel matrix is explicitly computed,
* which might be inappropriate for large-scale problems
*/
Entity(const char* filename, int k) {
sp_mat X = load(filename);
formCosKNNGraph(X, k);
}
bool saveSparseGraph(const char* filename);
private:
void formCosKNNGraph(const sp_mat& X, int k);
sp_mat load(const char* filename);
bool loadSparseGraph(const char* filename);
};
class Relation {
public:
Relation(const char* filename, const Entity& e1, const Entity& e2) {
assert(load(filename, e1, e2));
}
/*
* @DEFINITION
* edge := (index_in_entity1, index_in_entity2, strength)
*/
std::vector<triplet> edges;
/*
* @FORMAT
* instance_id_for_e1 instance_id_for_e2
*/
private:
bool load(const char* filename, const Entity& e1, const Entity& e2);
};
class Result {
public:
val mae;
val rmse;
};
#endif
|
page 49,132
TITLE ExId - SImple Id Executors
;***
;exid.asm - executors for simple id references.
;
; Copyright <C> 1986, Microsoft Corporation
;
;Purpose:
;
; This module contains all exId executors.
;
; Simple variables may also be referenced by exVtRfxx executors.
; These are always nops, and are maintained with the nonspeed-
; critical nop executors.
;
; In general, these executors are very speed critical.
;
;
;****************************************************************************
.xlist
include version.inc
IncludeOnce architec
IncludeOnce context
IncludeOnce executor
IncludeOnce exint
IncludeOnce extort
IncludeOnce opaftqb4
IncludeOnce opid
IncludeOnce opstmt
IncludeOnce pcode
IncludeOnce pointers
IncludeOnce qbimsgs
IncludeOnce rtinterp
IncludeOnce scanner
IncludeOnce variable
.list
assumes cs, CODE
assumes es, NOTHING
assumes ss, DATA
RestoreVarTable equ <mov ds,cx>
sBegin CODE
subttl Public Load
;Added with [15]
;End of [15]
subttl Static Load
MakeExe exIdISLd2,opIdLd,ET_Imp
LODSWTX ;Pick up variable address operand
xchg ax,bx ;Move to base register
DbChk oVar,bx
push [pVarBx]
DispMac ;Dispatch to next executor
MakeExe exIdESLdI2,opIdLd,ET_I2
LODSWTX ;Pick up variable address operand
xchg ax,bx ;Move to base register
DbChk oVar,bx
push [pVarBx] ;Push the I2
DispMac ;Dispatch to next executor
MakeExe exIdESLdI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdISLd4,opIdLd,ET_Imp
LODSWTX
xchg ax,bx ;Move to base register
DbChk oVar,bx
push [pVarBx+2]
push [pVarBx]
DispMac
;Added with [18]
MakeExe exIdESLdR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdISLdR4,opIdLd,ET_Imp
LODSWTX
xchg ax,bx ;Move to base register
DbChk oVar,bx
fld dword ptr [pVarBx]
DispMac
MakeExe exIdESLdR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdISLdR8,opIdLd,ET_Imp
LODSWTX
xchg ax,bx ;Move to base register
DbChk oVar,bx
fld qword ptr [pVarBx]
DispMac
;End of [18]
subttl Common Load
MakeExe exIdECLdI2,opIdLd,ET_I2
SkipExHeader
MakeExe exIdICLd2,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
push [bx]
DispMac
MakeExe exIdECLdI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdICLd4,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
push [bx+2]
push [bx]
DispMac
;Added with [18]
MakeExe exIdECLdR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdICLdR4,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
fld dword ptr [bx]
DispMac
MakeExe exIdECLdR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdICLdR8,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
fld qword ptr [bx]
DispMac
;End of [18]
subttl Indirect Load
page
MakeExe exIdEILdI2,opIdLd,ET_I2
SkipExHeader
MakeExe exIdIILd2,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Load address of variable
push [bx] ;Push the I2
DispMac
MakeExe exIdEILdI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdIILd4,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Load address of variable
push [bx+2]
push [bx]
DispMac
;Start of [18]
MakeExe exIdEILdR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdIILdR4,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Load address of variable
fld dword ptr [bx]
DispMac
MakeExe exIdEILdR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdIILdR8,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Load address of variable
fld qword ptr [bx]
DispMac
;End of [18]
subttl Frame Load and Indirect Reference
page
; The executors for loading two byte and four byte frame variables are
; also used for references to indirect variables. For a load of a frame
; variable, the variable table contains the value which is pushed on the
; stack. For a reference to an indirect variable, the variable table
; contains the address which is then pushed on the stack. Since addresses
; are either two or four bytes, only these entries serve two purposes.
MakeExe exIdIIRfTyp,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
mov bx,[pVarBx] ;Get oFrame
add bx,bp ;oFrame to pFrame entry
push ds
push [bx]
DispMac
MakeExe exIdEIRfR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdEIRfSD,opIdLd,ET_SD
SkipExHeader
MakeExe exIdEIRfI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdEIRfR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdEFLdI2,opIdLd,ET_I2
SkipExHeader
MakeExe exIdIFLd2,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
push [pFrame] ;Push the I2
DispMac
MakeExe exIdEFLdI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdIFLd4,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
push [pFrame+2]
push [pFrame]
DispMac
;Added with [18]
MakeExe exIdEFLdR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdIFLdR4,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
fld dword ptr [pFrame]
DispMac
MakeExe exIdEFLdR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdIFLdR8,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
fld qword ptr [pFrame]
DispMac
;End of [18]
subttl Public Store
page
;Added with [15]
;End of [15]
subttl Static Store
page
MakeExe exIdESStSD,opIdSt,ET_SD
SkipExHeader
MakeExe exIdISStSD,opIdSt,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;ax = pSdStore
push ax
CALLRT B$SASS,DispMov
MakeExe exIdISSt2,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
pop [pVarBx] ;Store stack in value
DispMac
MakeExe exIdESStI2,opIdSt,ET_I2
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
pop [pVarBx] ;Store stack in value
DispMac
MakeExe exIdESStI4,opIdSt,ET_I4
SkipExHeader
MakeExe exIdISSt4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
pop [pVarBx] ;Store stack in value
pop [pVarBx+2]
DispMac
;Added with [18]
MakeExe exIdESStR4,opIdSt,ET_R4
SkipExHeader
MakeExe exIdISStR4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
fstp dword ptr [pVarBx]
fwait
DispMac
MakeExe exIdESStR8,opIdSt,ET_R8
SkipExHeader
MakeExe exIdISStR8,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
fstp qword ptr [pVarBx]
fwait
DispMac
;End of [18]
MakeExe exIdISStTyp,opIdSt,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
xchg di,ax ;Destination (points to value field)
mov bx,[di-VAR_value].VAR_oTyp ;Get oTyp
push ds
jmp MoveRec
subttl Common Store
page
MakeExe exIdECStI2,opIdSt,ET_I2
SkipExHeader
MakeExe exIdICSt2,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
pop [bx]
DispMac
MakeExe exIdECStI4,opIdSt,ET_I4
SkipExHeader
MakeExe exIdICSt4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
pop [bx]
pop [bx+2]
DispMac
;Added with [18]
MakeExe exIdECStR4,opIdSt,ET_R4
SkipExHeader
MakeExe exIdICStR4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
fstp dword ptr [bx]
fwait
DispMac
MakeExe exIdECStR8,opIdSt,ET_R8
SkipExHeader
MakeExe exIdICStR8,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
fstp qword ptr [bx]
fwait
DispMac
;End of [18]
MakeExe exIdECStSD,opIdSt,ET_SD
SkipExHeader
MakeExe exIdICStSD,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
push bx ;Push pSD
CALLRT B$SASS,DispMov
MakeExe exIdICStTyp,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx
DbChk oVar,bx ; Check for valid oVar
mov cx,[pVarBx].COMREF_oValue ;Offset into common block
mov ax,[pVarBx].COMREF_oCommon ;oCommon
mov bx,[pVarBx-VAR_value].VAR_oTyp ;Get oTyp
add ax,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
xchg ax,di
mov di,[di].COM_bdValue.BD_pb ;Common block
add di,cx ;Offset in block
push ds
;ax = saved di
;bx = oTyp of record
;di = offset of destination
;[sp] = segment of destination
;[sp+4]:[sp+2] = pointer to source
jmp MoveRec
subttl Frame Store
page
MakeExe exIdEFStI2,opIdSt,ET_I2
SkipExHeader
MakeExe exIdIFSt2,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
pop [pFrame]
DispMac
MakeExe exIdEFStI4,opIdSt,ET_I4
SkipExHeader
MakeExe exIdIFSt4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
pop [pFrame]
pop [pFrame+2]
DispMac
;Added with [18]
MakeExe exIdEFStR4,opIdSt,ET_R4
SkipExHeader
MakeExe exIdIFStR4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
fstp dword ptr [pFrame]
fwait
DispMac
MakeExe exIdEFStR8,opIdSt,ET_R8
SkipExHeader
MakeExe exIdIFStR8,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
fstp qword ptr [pFrame]
fwait
DispMac
;End of [18]
MakeExe exIdEFStSD,opIdSt,ET_SD
SkipExHeader
MakeExe exIdIFStSD,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx] ;Get oBP
add ax,bp ;ax = pSD
push ax ;Push pSD
CALLRT B$SASS,DispMov
MakeExe exIdIFStTyp,opIdSt,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
xchg bx,ax ;pVar to bx
xchg ax,di ;Save di in ax
mov di,[bx] ;Get oBP
add di,bp
mov bx,[bx-VAR_value].VAR_oTyp ;Get oTyp
push ss
jmp MoveRec
subttl Indirect Store
MakeExe exIdEIStI2,opIdSt,ET_I2
SkipExHeader
MakeExe exIdIISt2,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Near address to bx
pop [bx]
DispMac ;Dispatch to next executor
MakeExe exIdEIStI4,opIdSt,ET_I4
SkipExHeader
MakeExe exIdIISt4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Near address to bx
pop [bx]
pop [bx+2]
DispMac ;Dispatch to next executor
;Added with [18]
MakeExe exIdEIStR4,opIdSt,ET_R4
SkipExHeader
MakeExe exIdIIStR4,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Near address to bx
fstp dword ptr [bx]
fwait
DispMac ;Dispatch to next executor
MakeExe exIdEIStR8,opIdSt,ET_R8
SkipExHeader
MakeExe exIdIIStR8,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
mov bx,[pFrame] ;Near address to bx
fstp qword ptr [bx]
fwait
DispMac ;Dispatch to next executor
;End of [18]
MakeExe exIdEIStSD,opIdSt,ET_SD
SkipExHeader
MakeExe exIdIIStSD,opIdSt,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
GetpFrame ;Get pointer into frame
push [pFrame] ; Push pSD/handle
CALLRT B$SASS,DispMov
MakeExe exIdIIStTyp,opIdSt,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
xchg bx,ax ;pVar to bx
xchg ax,di ;Save di in ax
mov di,[bx] ;Get oBP
mov bx,[bx-VAR_value].VAR_oTyp ;Get oTyp
push ds
mov di,[bp+di] ;Near address to di
jmp MoveRec
subttl Public IdRf Executors
page
;Added with [15]
;End of [15]
subttl Static IdRf Executors
page
MakeExe exIdISRfTyp,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
push ds ;Push far pointer
push ax
DispMac
MakeExe exIdESRfR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdESRfI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdESRfSD,opIdLd,ET_SD
SkipExHeader
MakeExe exIdESRfR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdESRfI2,opIdLd,ET_I2
SkipExHeader
MakeExe exIdISRf,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
push ax
DispMac
SameExe exIdISLdSD,exIdISRf
SameExe exIdESLdSD,exIdESRfSD
subttl Frame IdRf Executors
page
MakeExe exIdIFRfTyp,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax ;Move to base register
mov ax,[pVarBx] ;Get oFrame
add ax,bp ;oFrame to pValue
push ds
push ax
DispMac
MakeExe exIdEFRfR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdEFRfSD,opIdLd,ET_SD
SkipExHeader
MakeExe exIdEFRfI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdEFRfR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdEFRfI2,opIdLd,ET_I2
SkipExHeader
MakeExe exIdIFRf,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax ;Move to base register
mov ax,[pVarBx] ;Get oFrame
add ax,bp ;oFrame to pValue
push ax
DispMac
SameExe exIdIFLdSD,exIdIFRf
subttl Common IdRf Executors
page
MakeExe exIdICRfTyp,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
push ds
push bx
DispMac
MakeExe exIdECRfR8,opIdLd,ET_R8
SkipExHeader
MakeExe exIdECRfSD,opIdLd,ET_SD
SkipExHeader
MakeExe exIdECRfI4,opIdLd,ET_I4
SkipExHeader
MakeExe exIdECRfR4,opIdLd,ET_R4
SkipExHeader
MakeExe exIdECRfI2,opIdLd,ET_I2
SkipExHeader
MakeExe exIdICRf,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax
mov ax,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,ax ;Offset in block
push bx
DispMac
SameExe exIdICLdSD,exIdICRf
SameExe exIdECLdSD,exIdECRfSD
subttl FS load/store/ref executors
page
MakeExe exIdESRfFS,opIdLd,ET_SD
SkipExHeader
MakeExe exIdISRfFS,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
xchg bx,ax ;pVar to bx
push ds
push bx ;Far address to stack
push [bx-VAR_value].VAR_cbFixed ; Push length of FS
DispMac
MakeExe exIdEIRfFS,opIdLd,ET_SD
SkipExHeader
MakeExe exIdIIRfFS,opIdLd,ET_Imp
LODSWTX ;Get oVar
xchg ax,bx ;Move to base register
DbChk oVar,bx ; Check for valid oVar
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
GetpFrame ;Get pointer into frame
push ds
push [pFrame] ;Push offset
push ax ;Push cb in FS
DispMac
MakeExe exIdEFRfFS,opIdLd,ET_SD
SkipExHeader
MakeExe exIdIFRfFS,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax ;Move to base register
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
mov bx,[pVarBx] ;Get oFrame
add bx,bp ;oFrame to pFrame entry
push ss
push bx
push ax ;Push cb in FS
DispMac
MakeExe exIdESLdFS,opIdLd,ET_SD
SkipExHeader
MakeExe exIdISLdFS,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
xchg bx,ax ;pVar to bx
push ds
push bx ;Far address to stack
push [bx-VAR_value].VAR_cbFixed ; Push length of FS
CALLRT B$LDFS,DispMovSd
MakeExe exIdEILdFS,opIdLd,ET_SD
SkipExHeader
MakeExe exIdIILdFS,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax ;Move to base register
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
GetpFrame ;Get pointer into frame
push ds
push [pFrame] ;Push offset
push ax ;Push cb in FS
CALLRT B$LDFS,DispMovSd
MakeExe exIdEFLdFS,opIdLd,ET_SD
SkipExHeader
MakeExe exIdIFLdFS,opIdLd,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax ;Move to base register
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
mov bx,[pVarBx] ;Get oFrame
add bx,bp ;oFrame to pFrame entry
push ss
push bx
push ax ;Push cb in FS
CALLRT B$LDFS,DispMovSd
MakeExe exIdESStFS,opIdSt,ET_SD
SkipExHeader
MakeExe exIdISStFS,opIdSt,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
add ax,di ;oVar --> pVar
xchg bx,ax ;pVar to bx
push ds
push bx ;Far address to stack
push [bx-VAR_value].VAR_cbFixed ; Push length of FS
CALLRT B$LSET,Disp
MakeExe exIdEIStFS,opIdSt,ET_SD
SkipExHeader
MakeExe exIdIIStFS,opIdSt,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax ;Move to base register
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
GetpFrame ;Get pointer into frame
push ds
push [pFrame] ;Push offset
push ax ;Push cb in FS
CALLRT B$LSET,Disp
MakeExe exIdEFStFS,opIdSt,ET_SD
SkipExHeader
MakeExe exIdIFStFS,opIdSt,ET_Imp
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax ;Move to base register
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
mov bx,[pVarBx] ;Get oFrame
add bx,bp ;oFrame to pFrame entry
push ss
push bx
push ax ;Push cb in FS
CALLRT B$LSET,Disp
MakeExe exIdICRfFS,opIdLd,ET_Imp
SkipExHeader
MakeExe exIdECRfFS,opIdLd,ET_SD
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
mov cx,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,cx ;Offset in block
push ds
push bx
push ax ;Push cb in FS
DispMac
MakeExe exIdICLdFS,opIdLd,ET_Imp
SkipExHeader
MakeExe exIdECLdFS,opIdLd,ET_SD
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
mov cx,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,cx ;Offset in block
push ds
push bx
push ax ;Push cb in FS
CALLRT B$LDFS,DispMovSd
MakeExe exIdICStFS,opIdSt,ET_Imp
SkipExHeader
MakeExe exIdECStFS,opIdSt,ET_SD
LODSWTX ;Get oVar
DbChk oVar,ax ; Check for valid oVar
xchg bx,ax
mov ax,[pVarBx-VAR_value].VAR_cbFixed ; Get length
mov cx,[pVarBx].COMREF_oValue ;Offset into common block
mov bx,[pVarBx].COMREF_oCommon ;oCommon
add bx,[grs.GRS_bdtComBlk.BD_pb] ;pCommon
mov bx,[bx].COM_bdValue.BD_pb ;Common block
add bx,cx ;Offset in block
push ds
push bx
push ax ;Push cb in FS
CALLRT B$LSET,Disp
SameExe exIdIIRf,exIdIFLd2
SameExe exIdEIRfI2,exIdEFLdI2
;*************************************************************************
MakeExe exStDim,opStDim
inc si
inc si ;Eat the operand
DispMac
sEnd CODE
end
|
/**
* Copyright (c) 2018-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "logdevice/common/membership/StorageMembership.h"
#include <algorithm>
#include <folly/Format.h>
#include "logdevice/common/debug.h"
#include "logdevice/common/membership/utils.h"
#include "logdevice/common/util.h"
#include "logdevice/include/Err.h"
namespace facebook { namespace logdevice { namespace membership {
using facebook::logdevice::toString;
using namespace MembershipVersion;
using namespace MaintenanceID;
std::string ShardState::Update::toString() const {
return folly::sformat("[T:{}, C:{}, M:{}]",
membership::toString(transition),
Condition::toString(conditions),
membership::toString(maintenance));
}
bool ShardState::Update::isValid() const {
if (transition >= StorageStateTransition::Count) {
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"Invalid transition %lu for update %s.",
static_cast<size_t>(transition),
toString().c_str());
return false;
}
if (isProvisionShard(transition) && maintenance != MAINTENANCE_PROVISION) {
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"Maintencance version must be MAINTENANCE_PROVISION "
"for a provisioning update. Update: %s.",
toString().c_str());
return false;
}
if (transition == StorageStateTransition::OVERRIDE_STATE &&
!state_override.hasValue()) {
RATELIMIT_ERROR(
std::chrono::seconds(10),
5,
"Invalid transition %lu for update %s: state_override not provided.",
static_cast<size_t>(transition),
toString().c_str());
return false;
}
return true;
}
bool ShardState::isValid() const {
if (storage_state == StorageState::INVALID ||
metadata_state == MetaDataStorageState::INVALID ||
since_version == EMPTY_VERSION) {
// since_version should never be 0 (EMPTY)
return false;
}
if (metadata_state == MetaDataStorageState::PROMOTING &&
storage_state != StorageState::READ_WRITE) {
// PROMOTING metadata storage state should only happen in READ_WRITE
return false;
}
if ((flags & StorageStateFlags::UNRECOVERABLE) &&
(storage_state == StorageState::NONE ||
storage_state == StorageState::NONE_TO_RO)) {
return false;
}
return true;
}
std::string ShardState::toString() const {
return folly::sformat("[S:{}, F:{}, M:{}, A:{}, V:{}]",
membership::toString(storage_state),
StorageStateFlags::toString(flags),
membership::toString(metadata_state),
membership::toString(active_maintenance),
membership::toString(since_version));
}
/* static */
int ShardState::transition(const ShardState& current_state,
Update update,
MembershipVersion::Type new_since_version,
ShardState* state_out) {
if (!update.isValid()) {
err = E::INVALID_PARAM;
return -1;
}
if (!isAddingNewShard(update.transition) && !current_state.isValid()) {
// current source state must be valid except for the four transitions that
// add a new shard
err = E::INVALID_PARAM;
return -1;
}
ShardState target_shard_state(current_state);
// Step 1: Check the current storage state and conditions, and determine
// the target storage_state by looking up the TransitionTable
const StorageState expected_state = source_state(update.transition);
if (expected_state != StorageState::INVALID &&
expected_state != current_state.storage_state) {
err = E::SOURCE_STATE_MISMATCH;
return -1;
}
const StateTransitionCondition expected_conditions =
required_conditions(update.transition);
// check transition conditions; Also if the FORCE flag is presented, bypass
// the condition check
if (!Condition::hasAllConditionsOrForce(
update.conditions, expected_conditions)) {
err = E::CONDITION_MISMATCH;
return -1;
}
const StorageState target_storage_state = target_state(update.transition);
if (target_storage_state != StorageState::INVALID) {
target_shard_state.storage_state = target_storage_state;
}
// Step 2: Determine the flags and MetaDataStorageState, as well as certain
// transition specific processing
StorageStateFlags::Type target_flags = current_state.flags;
MetaDataStorageState target_metadata_state = current_state.metadata_state;
switch (update.transition) {
case StorageStateTransition::PROVISION_SHARD:
case StorageStateTransition::PROVISION_METADATA_SHARD: {
// provisioning new shards for the newly created cluster
if (new_since_version != MIN_VERSION) {
// perform version check leveraging that new_since_version ==
// base_version + 1
RATELIMIT_ERROR(
std::chrono::seconds(10),
5,
"Cannnot apply a provisioning shard update with base version "
"other than EMPTY_VERSION %s. Update: %s, "
"New since version: %s.",
membership::toString(EMPTY_VERSION).c_str(),
update.toString().c_str(),
membership::toString(new_since_version).c_str());
err = E::VERSION_MISMATCH;
return -1;
}
ld_check(target_shard_state.storage_state == StorageState::READ_WRITE);
target_flags = StorageStateFlags::NONE;
target_metadata_state =
(update.transition == StorageStateTransition::PROVISION_METADATA_SHARD
? MetaDataStorageState::METADATA
: MetaDataStorageState::NONE);
} break;
case StorageStateTransition::ADD_EMPTY_SHARD:
case StorageStateTransition::ADD_EMPTY_METADATA_SHARD: {
ld_check(target_shard_state.storage_state == StorageState::NONE);
target_flags = StorageStateFlags::NONE;
target_metadata_state =
(update.transition == StorageStateTransition::ADD_EMPTY_METADATA_SHARD
? MetaDataStorageState::METADATA
: MetaDataStorageState::NONE);
} break;
case StorageStateTransition::DISABLING_WRITE: {
// 1) If the metadata storage state of the shard is METADATA, then require
// additional checks on metadata write availability and capacity;
// 2) If the metadata storage state of the shard is PROMOTING, abort the
// promoting and rever the state back to NONE
switch (current_state.metadata_state) {
case MetaDataStorageState::METADATA:
if (!Condition::hasAllConditionsOrForce(
update.conditions,
(Condition::WRITE_AVAILABILITY_CHECK |
Condition::METADATA_CAPACITY_CHECK))) {
err = E::CONDITION_MISMATCH;
return -1;
}
break;
case MetaDataStorageState::PROMOTING:
target_metadata_state = MetaDataStorageState::NONE;
break;
case MetaDataStorageState::NONE:
break;
case MetaDataStorageState::INVALID:
ld_check(false);
break;
}
} break;
case StorageStateTransition::DATA_MIGRATION_COMPLETED: {
ld_check(current_state.storage_state == StorageState::DATA_MIGRATION);
// if the shard has the UNRECOVERABLE flag, clear it
target_flags &= ~(StorageStateFlags::UNRECOVERABLE);
} break;
case StorageStateTransition::PROMOTING_METADATA_SHARD: {
// enforced by the transition table
ld_check(current_state.storage_state == StorageState::READ_WRITE);
ld_check(target_shard_state.storage_state == StorageState::READ_WRITE);
// additional conditions: current metadata storage state must be NONE
if (current_state.metadata_state != MetaDataStorageState::NONE) {
err = E::SOURCE_STATE_MISMATCH;
return -1;
}
// metadata state: NONE -> PROMOTING
target_metadata_state = MetaDataStorageState::PROMOTING;
} break;
case StorageStateTransition::COMMIT_PROMOTION_METADATA_SHARD: {
// enforced by the transition table
ld_check(current_state.storage_state == StorageState::READ_WRITE);
ld_check(target_shard_state.storage_state == StorageState::READ_WRITE);
// additional conditions: check the current metadata state must
// be PROMOTING
if (current_state.metadata_state != MetaDataStorageState::PROMOTING) {
err = E::SOURCE_STATE_MISMATCH;
return -1;
}
// metadata state: PROMOTING -> METADATA
target_metadata_state = MetaDataStorageState::METADATA;
} break;
case StorageStateTransition::ABORT_PROMOTING_METADATA_SHARD: {
// enforced by the transition table
ld_check(current_state.storage_state == StorageState::READ_WRITE);
ld_check(target_shard_state.storage_state == StorageState::READ_WRITE);
// additional conditions: current metadata storage state must be PROMOTING
if (current_state.metadata_state != MetaDataStorageState::PROMOTING) {
err = E::SOURCE_STATE_MISMATCH;
return -1;
}
// metadata state: PROMOTING -> NONE
target_metadata_state = MetaDataStorageState::NONE;
} break;
case StorageStateTransition::MARK_SHARD_UNRECOVERABLE: {
// additional conditions: 1) current storage state must be one of
// {ro, rw, rw2ro, dm, none2ro} state. 2) existing shard state
// shouldn't have the UNRECOVERABLE flag. 3) if the shard is in none2ro
// state, marking it as UNRECOVERABLE should automatically abort the
// none->ro transition and make the shard transition back to NONE
switch (current_state.storage_state) {
case StorageState::NONE:
ld_check(target_shard_state.storage_state == StorageState::NONE);
// for storage state NONE this operation is a no-op
break;
case StorageState::NONE_TO_RO:
// abort the enabling read attempt and make the storage state go back
// to NONE
target_shard_state.storage_state = StorageState::NONE;
break;
case StorageState::READ_ONLY:
case StorageState::READ_WRITE:
case StorageState::RW_TO_RO:
case StorageState::DATA_MIGRATION: {
// In these situations, this operation shouldn't change the storage
// state
ld_check(target_shard_state.storage_state ==
current_state.storage_state);
if (current_state.flags & StorageStateFlags::UNRECOVERABLE) {
err = E::ALREADY;
return -1;
}
target_flags |= StorageStateFlags::UNRECOVERABLE;
} break;
case StorageState::INVALID:
err = E::INTERNAL;
return -1;
}
// metadata storage state keeps the same
} break;
case StorageStateTransition::OVERRIDE_STATE: {
// must have the force flag in conditions
ld_check(update.conditions & Condition::FORCE);
ld_check(update.state_override.hasValue());
const auto& state_override = update.state_override.value();
// blindly overwrite the shard state to the target overrid state
target_shard_state.storage_state = state_override.storage_state;
target_flags = state_override.flags;
target_metadata_state = state_override.metadata_state;
} break;
case StorageStateTransition::REMOVE_EMPTY_SHARD:
case StorageStateTransition::ENABLING_READ:
case StorageStateTransition::COMMIT_READ_ENABLED:
case StorageStateTransition::ENABLE_WRITE:
case StorageStateTransition::COMMIT_WRITE_DISABLED:
case StorageStateTransition::START_DATA_MIGRATION:
case StorageStateTransition::ABORT_ENABLING_READ:
case StorageStateTransition::ABORT_DISABLING_WRITE:
case StorageStateTransition::CANCEL_DATA_MIGRATION:
break;
case StorageStateTransition::Count:
err = E::INTERNAL;
return -1;
}
target_shard_state.flags = target_flags;
target_shard_state.metadata_state = target_metadata_state;
target_shard_state.since_version = new_since_version;
target_shard_state.active_maintenance = update.maintenance;
if (!target_shard_state.isValid() &&
update.transition != StorageStateTransition::REMOVE_EMPTY_SHARD) {
err = E::INTERNAL;
return -1;
}
if (state_out != nullptr) {
*state_out = target_shard_state;
}
return 0;
}
bool StorageMembership::Update::isValid() const {
return !shard_updates.empty() &&
std::all_of(shard_updates.cbegin(),
shard_updates.cend(),
[](const auto& kv) { return kv.second.isValid(); });
}
std::string StorageMembership::Update::toString() const {
std::string shard_str;
bool first = true;
for (const auto& kv : shard_updates) {
if (!first) {
shard_str += ", ";
}
shard_str += folly::sformat(
"{{{}, {}}}", membership::toString(kv.first), kv.second.toString());
first = false;
}
return folly::sformat(
"[V:{}, {{{}}}]", membership::toString(base_version), shard_str);
}
std::pair<bool, ShardState>
StorageMembership::getShardState(ShardID shard) const {
const auto nit = node_states_.find(shard.node());
if (nit == node_states_.cend()) {
return std::make_pair(false, ShardState{});
}
const auto& shard_map = nit->second.shard_states;
const auto sit = shard_map.find(shard.shard());
if (sit == shard_map.cend()) {
return std::make_pair(false, ShardState{});
}
return std::make_pair(true, sit->second);
}
std::unordered_map<shard_index_t, ShardState>
StorageMembership::getShardStates(node_index_t node) const {
std::unordered_map<shard_index_t, ShardState> result;
const auto nit = node_states_.find(node);
if (nit == node_states_.cend()) {
return result;
}
return nit->second.shard_states;
}
void StorageMembership::setShardState(ShardID shard, ShardState state) {
// caller must ensure that the given state is valid
ld_check(state.isValid());
node_states_[shard.node()].shard_states[shard.shard()] = state;
if (state.metadata_state != MetaDataStorageState::NONE) {
// also update the metadata shard index
metadata_shards_.insert(shard);
} else {
metadata_shards_.erase(shard);
}
}
void StorageMembership::eraseShardState(ShardID shard) {
auto nit = node_states_.find(shard.node());
if (nit != node_states_.end()) {
auto& shard_map = nit->second.shard_states;
shard_map.erase(shard.shard());
if (shard_map.empty()) {
// no shard exist anymore, also erase the entire node state
node_states_.erase(nit);
}
}
// also erase the shard from metadata shard index
metadata_shards_.erase(shard);
}
int StorageMembership::applyUpdate(const Membership::Update& membership_update,
Membership* new_membership_out) const {
if (membership_update.getType() != MembershipType::STORAGE ||
(new_membership_out != nullptr &&
new_membership_out->getType() != MembershipType::STORAGE)) {
RATELIMIT_ERROR(
std::chrono::seconds(10),
5,
"Expect update and/or out params of storage membership type!");
err = E::INVALID_PARAM;
return -1;
}
const StorageMembership::Update& update =
checked_downcast<const StorageMembership::Update&>(membership_update);
StorageMembership* new_storage_membership_out =
checked_downcast_or_null<StorageMembership*>(new_membership_out);
if (!update.isValid()) {
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"Cannnot apply invalid membership update: %s.",
update.toString().c_str());
err = E::INVALID_PARAM;
return -1;
}
if (version_ != update.base_version) {
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"Cannnot apply membership update with wrong base version."
"current version: %s, update: %s.",
membership::toString(version_).c_str(),
update.toString().c_str());
err = E::VERSION_MISMATCH;
return -1;
}
StorageMembership target_membership_state(*this);
// bump the version in the target state
target_membership_state.version_ =
MembershipVersion::Type(version_.val() + 1);
for (const auto& kv : update.shard_updates) {
const ShardID shard = kv.first;
const ShardState::Update& shard_update = kv.second;
// Step 1: get the current ShardState of the shard of the requested shard
bool shard_exist;
ShardState current_shard_state;
std::tie(shard_exist, current_shard_state) = getShardState(shard);
if (!shard_exist) {
if (!isAddingNewShard(shard_update.transition)) {
// shard must exist in the current membership with the only exception of
// ADD_EMPTY_(METADATA_)SHARD or PROVISION_(METADATA_)SHARD
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"Cannnot apply membership update for shard %s as it "
"does not exist in membership. current version: %s, "
"update: %s.",
membership::toString(shard).c_str(),
membership::toString(version_).c_str(),
update.toString().c_str());
err = E::NOTINCONFIG;
return -1;
}
// create an initial current state
current_shard_state = {StorageState::INVALID,
StorageStateFlags::NONE,
MetaDataStorageState::NONE,
MAINTENANCE_NONE,
EMPTY_VERSION};
} else {
if (isAddingNewShard(shard_update.transition)) {
RATELIMIT_ERROR(
std::chrono::seconds(10),
5,
"Cannnot apply membership update for shard %s as the shard "
"requested to add already exists in membership. current "
"version: %s, update: %s.",
membership::toString(shard).c_str(),
membership::toString(version_).c_str(),
update.toString().c_str());
err = E::EXISTS;
return -1;
}
}
ShardState target_shard_state;
int rv = ShardState::transition(current_shard_state,
shard_update,
target_membership_state.version_,
&target_shard_state);
if (rv != 0) {
// err set by transition()
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"Failed to apply membership update for shard %s: %s. "
"current version: %s, current shard state: %s, "
"update: %s.",
membership::toString(shard).c_str(),
error_description(err),
membership::toString(version_).c_str(),
current_shard_state.toString().c_str(),
update.toString().c_str());
return -1;
}
// commit the target ShardState, also maintain the metadata_shards_ index.
if (shard_update.transition == StorageStateTransition::REMOVE_EMPTY_SHARD) {
target_membership_state.eraseShardState(shard);
} else {
ld_check(target_shard_state.isValid());
target_membership_state.setShardState(shard, target_shard_state);
}
}
if (new_storage_membership_out != nullptr) {
*new_storage_membership_out = target_membership_state;
}
dcheckConsistency();
return 0;
}
bool StorageMembership::validate() const {
if (version_ == EMPTY_VERSION && !isEmpty()) {
RATELIMIT_ERROR(
std::chrono::seconds(10),
5,
"validation failed! Memership is not empty with empty version: %s. "
"Number of nodes: %lu.",
membership::toString(version_).c_str(),
numNodes());
return false;
}
std::set<ShardID> expected_metadata_shard;
for (const auto& np : node_states_) {
for (const auto& sp : np.second.shard_states) {
ShardID shard(np.first, sp.first);
const ShardState& st = sp.second;
if (!st.isValid()) {
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"validation failed! invalid shard state for shard %s: "
"%s. membership version: %s.",
membership::toString(shard).c_str(),
st.toString().c_str(),
membership::toString(version_).c_str());
return false;
}
if (st.since_version > version_) {
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"validation failed! invalid effective since version "
"for shard %s: %s. membership version: %s.",
membership::toString(shard).c_str(),
st.toString().c_str(),
membership::toString(version_).c_str());
return false;
}
if (st.metadata_state != MetaDataStorageState::NONE) {
expected_metadata_shard.insert(shard);
}
}
}
if (expected_metadata_shard != metadata_shards_) {
RATELIMIT_ERROR(std::chrono::seconds(10),
5,
"validation failed! inconsistent metadata shards index, "
"expected: %s, actual %s. membership version: %s.",
membership::toString(expected_metadata_shard).c_str(),
membership::toString(metadata_shards_).c_str(),
membership::toString(version_).c_str());
return false;
}
return true;
}
std::vector<node_index_t> StorageMembership::getMembershipNodes() const {
std::vector<node_index_t> res;
res.reserve(node_states_.size());
for (const auto& kv : node_states_) {
res.push_back(kv.first);
}
return res;
}
bool StorageMembership::canWriteToShard(ShardID shard) const {
auto result = getShardState(shard);
return result.first ? canWriteTo(result.second.storage_state) : false;
}
bool StorageMembership::shouldReadFromShard(ShardID shard) const {
auto result = getShardState(shard);
return result.first ? shouldReadFrom(result.second.storage_state) : false;
}
bool StorageMembership::canWriteMetaDataToShard(ShardID shard) const {
auto result = getShardState(shard);
return (result.first ? canWriteMetaDataTo(result.second.storage_state,
result.second.metadata_state)
: false);
}
bool StorageMembership::shouldReadMetaDataFromShard(ShardID shard) const {
auto result = getShardState(shard);
return (result.first ? shouldReadMetaDataFrom(result.second.storage_state,
result.second.metadata_state)
: false);
}
StorageMembership::StorageMembership() : Membership(EMPTY_VERSION) {
dcheckConsistency();
}
namespace {
template <typename Container, typename Pred>
StorageSet storageset_filter(const Container& container, Pred pred) {
StorageSet result;
std::copy_if(
container.begin(), container.end(), std::back_inserter(result), pred);
return result;
}
} // namespace
StorageSet StorageMembership::writerView(const StorageSet& storage_set) const {
return storageset_filter(storage_set, [this](ShardID shard) {
return this->canWriteToShard(shard);
});
}
StorageSet StorageMembership::readerView(const StorageSet& storage_set) const {
return storageset_filter(storage_set, [this](ShardID shard) {
return this->shouldReadFromShard(shard);
});
}
StorageSet StorageMembership::writerViewMetaData() const {
return storageset_filter(metadata_shards_, [this](ShardID shard) {
return this->canWriteMetaDataToShard(shard);
});
}
StorageSet StorageMembership::readerViewMetaData() const {
return storageset_filter(metadata_shards_, [this](ShardID shard) {
return this->shouldReadMetaDataFromShard(shard);
});
}
StorageSet StorageMembership::getMetaDataStorageSet() const {
return storageset_filter(
metadata_shards_, [](ShardID shard) { return true; });
}
bool StorageMembership::isInMetadataStorageSet(ShardID shard) const {
return metadata_shards_.count(shard);
}
bool StorageMembership::operator==(const StorageMembership& rhs) const {
return version_ == rhs.getVersion() && node_states_ == rhs.node_states_ &&
metadata_shards_ == rhs.metadata_shards_;
}
bool StorageMembership::hasShard(ShardID shard) const {
const auto nit = node_states_.find(shard.node());
if (nit == node_states_.cend()) {
return false;
}
return nit->second.hasShard(shard.shard());
}
}}} // namespace facebook::logdevice::membership
|
; ==================================================================
; MikeOS -- The Mike Operating System kernel
; Copyright (C) 2006 - 2019 MikeOS Developers -- see doc/LICENSE.TXT
;
; PORT INPUT AND OUTPUT ROUTINES
; ==================================================================
; ------------------------------------------------------------------
; os_port_byte_out -- Send byte to a port
; IN: DX = port address, AL = byte to send
os_port_byte_out:
pusha
out dx, al
popa
ret
; ------------------------------------------------------------------
; os_port_byte_in -- Receive byte from a port
; IN: DX = port address
; OUT: AL = byte from port
os_port_byte_in:
pusha
in al, dx
mov word [.tmp], ax
popa
mov ax, [.tmp]
ret
.tmp dw 0
; ------------------------------------------------------------------
; os_serial_port_enable -- Set up the serial port for transmitting data
; IN: AX = 0 for normal mode (9600 baud), or 1 for slow mode (1200 baud)
os_serial_port_enable:
pusha
mov dx, 0 ; Configure serial port 1
cmp ax, 1
je .slow_mode
mov ah, 0
mov al, 11100011b ; 9600 baud, no parity, 8 data bits, 1 stop bit
jmp .finish
.slow_mode:
mov ah, 0
mov al, 10000011b ; 1200 baud, no parity, 8 data bits, 1 stop bit
.finish:
int 14h
popa
ret
; ------------------------------------------------------------------
; os_send_via_serial -- Send a byte via the serial port
; IN: AL = byte to send via serial; OUT: AH = Bit 7 clear on success
os_send_via_serial:
pusha
mov ah, 01h
mov dx, 0 ; COM1
int 14h
mov [.tmp], ax
popa
mov ax, [.tmp]
ret
.tmp dw 0
; ------------------------------------------------------------------
; os_get_via_serial -- Get a byte from the serial port
; OUT: AL = byte that was received; OUT: AH = Bit 7 clear on success
os_get_via_serial:
pusha
mov ah, 02h
mov dx, 0 ; COM1
int 14h
mov [.tmp], ax
popa
mov ax, [.tmp]
ret
.tmp dw 0
; ==================================================================
|
/// @file
/// Commodore 64 Registers and Constants
/// @file
/// The MOS 6526 Complex Interface Adapter (CIA)
///
/// http://archive.6502.org/datasheets/mos_6526_cia_recreated.pdf
// Commodore 64 PRG executable file
.file [name="sinus-sprites.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
.const sinlen_x = $dd
.const sinlen_y = $c5
.const OFFSET_STRUCT_MOS6569_VICII_RASTER = $12
.const OFFSET_STRUCT_MOS6569_VICII_BORDER_COLOR = $20
.const OFFSET_STRUCT_MOS6569_VICII_SPRITES_XMSB = $10
.const OFFSET_STRUCT_MOS6569_VICII_SPRITES_ENABLE = $15
.const OFFSET_STRUCT_MOS6569_VICII_SPRITES_EXPAND_X = $1d
.const OFFSET_STRUCT_MOS6569_VICII_SPRITES_EXPAND_Y = $17
/// Sprite X position register for sprite #0
.label SPRITES_XPOS = $d000
/// Sprite Y position register for sprite #0
.label SPRITES_YPOS = $d001
/// Sprite colors register for sprite #0
.label SPRITES_COLOR = $d027
/// Processor Port Register controlling RAM/ROM configuration and the datasette
.label PROCPORT = 1
/// The address of the CHARGEN character set
.label CHARGEN = $d000
/// The VIC-II MOS 6567/6569
.label VICII = $d000
/// Color Ram
.label COLS = $d800
// Zeropage addresses used to hold lo/hi-bytes of addresses of float numbers in MEM
.label memLo = $fe
.label memHi = $ff
.label sprites = $2000
.label SCREEN = $400
// Current index within the progress cursor (0-7)
.label progress_idx = 5
// Current position of the progress cursor
.label progress_cursor = 3
.label sin_idx_x = 9
.label sin_idx_y = 6
.segment Code
main: {
// init()
jsr init
lda #0
sta.z sin_idx_y
sta.z sin_idx_x
__b1:
// while (VICII->RASTER!=$ff)
lda #$ff
cmp VICII+OFFSET_STRUCT_MOS6569_VICII_RASTER
bne __b1
// anim()
jsr anim
jmp __b1
}
init: {
// clear_screen()
jsr clear_screen
ldx #0
__b1:
// COLS[i] = $0
lda #0
sta COLS,x
// COLS[40+i] = $b
lda #$b
sta COLS+$28,x
// for( char i : 0..39)
inx
cpx #$28
bne __b1
// place_sprites()
jsr place_sprites
// gen_sprites()
jsr gen_sprites
// progress_init(SCREEN)
lda #<SCREEN
sta.z progress_init.line
lda #>SCREEN
sta.z progress_init.line+1
jsr progress_init
// gen_sintab(sintab_x, sinlen_x, $00, $ff)
lda #<sintab_x
sta.z gen_sintab.sintab
lda #>sintab_x
sta.z gen_sintab.sintab+1
lda #sinlen_x
sta.z gen_sintab.length
lda #0
sta.z gen_sintab.min
ldx #$ff
jsr gen_sintab
// progress_init(SCREEN+40)
lda #<SCREEN+$28
sta.z progress_init.line
lda #>SCREEN+$28
sta.z progress_init.line+1
jsr progress_init
// gen_sintab(sintab_y, sinlen_y, $32, $d0)
lda #<sintab_y
sta.z gen_sintab.sintab
lda #>sintab_y
sta.z gen_sintab.sintab+1
lda #sinlen_y
sta.z gen_sintab.length
lda #$32
sta.z gen_sintab.min
ldx #$d0
jsr gen_sintab
// clear_screen()
jsr clear_screen
// }
rts
}
anim: {
.label __7 = 8
.label xidx = 5
.label yidx = $c
.label x = $13
.label x_msb = 8
.label j2 = 2
.label j = $11
// (VICII->BORDER_COLOR)++;
inc VICII+OFFSET_STRUCT_MOS6569_VICII_BORDER_COLOR
// char xidx = sin_idx_x
lda.z sin_idx_x
sta.z xidx
// char yidx = sin_idx_y
lda.z sin_idx_y
sta.z yidx
lda #0
sta.z j
lda #$c
sta.z j2
lda #0
sta.z x_msb
__b3:
// unsigned int x = (unsigned int)$1e + sintab_x[xidx]
ldy.z xidx
lda sintab_x,y
clc
adc #<$1e
sta.z x
lda #>$1e
adc #0
sta.z x+1
// x_msb*2
asl.z __7
// BYTE1(x)
// x_msb = x_msb*2 | BYTE1(x)
ora.z x_msb
sta.z x_msb
// BYTE0(x)
lda.z x
// SPRITES_XPOS[j2] = BYTE0(x)
ldy.z j2
sta SPRITES_XPOS,y
// SPRITES_YPOS[j2] = sintab_y[yidx]
ldy.z yidx
lda sintab_y,y
ldy.z j2
sta SPRITES_YPOS,y
// xidx = xidx+10
lax.z xidx
axs #-[$a]
stx.z xidx
// if(xidx>=sinlen_x)
txa
cmp #sinlen_x
bcc __b4
// xidx = xidx-sinlen_x
lax.z xidx
axs #sinlen_x
stx.z xidx
__b4:
// yidx = yidx+8
lax.z yidx
axs #-[8]
stx.z yidx
// if(yidx>=sinlen_y)
txa
cmp #sinlen_y
bcc __b5
// yidx = yidx-sinlen_y
lax.z yidx
axs #sinlen_y
stx.z yidx
__b5:
// j2 = j2-2
dec.z j2
dec.z j2
// for( char j : 0..6)
inc.z j
lda #7
cmp.z j
bne __b3
// VICII->SPRITES_XMSB = x_msb
lda.z x_msb
sta VICII+OFFSET_STRUCT_MOS6569_VICII_SPRITES_XMSB
// if(++sin_idx_x>=sinlen_x)
inc.z sin_idx_x
lda.z sin_idx_x
cmp #sinlen_x
bcc __b1
lda #0
sta.z sin_idx_x
__b1:
// if(++sin_idx_y>=sinlen_y)
inc.z sin_idx_y
lda.z sin_idx_y
cmp #sinlen_y
bcc __b2
lda #0
sta.z sin_idx_y
__b2:
// (VICII->BORDER_COLOR)--;
dec VICII+OFFSET_STRUCT_MOS6569_VICII_BORDER_COLOR
// }
rts
}
clear_screen: {
.label sc = $f
lda #<SCREEN
sta.z sc
lda #>SCREEN
sta.z sc+1
__b1:
// for(char* sc = SCREEN; sc<SCREEN+1000; sc++)
lda.z sc+1
cmp #>SCREEN+$3e8
bcc __b2
bne !+
lda.z sc
cmp #<SCREEN+$3e8
bcc __b2
!:
// }
rts
__b2:
// *sc = ' '
lda #' '
ldy #0
sta (sc),y
// for(char* sc = SCREEN; sc<SCREEN+1000; sc++)
inc.z sc
bne !+
inc.z sc+1
!:
jmp __b1
}
place_sprites: {
.label sprites_ptr = SCREEN+$3f8
.label spr_id = 9
.label spr_x = 5
.label col = 2
.label j2 = 8
.label j = 6
// VICII->SPRITES_ENABLE = %01111111
lda #$7f
sta VICII+OFFSET_STRUCT_MOS6569_VICII_SPRITES_ENABLE
// VICII->SPRITES_EXPAND_X = %01111111
sta VICII+OFFSET_STRUCT_MOS6569_VICII_SPRITES_EXPAND_X
// VICII->SPRITES_EXPAND_Y = %01111111
sta VICII+OFFSET_STRUCT_MOS6569_VICII_SPRITES_EXPAND_Y
lda #5
sta.z col
lda #0
sta.z j2
lda #$3c
sta.z spr_x
lda #0
sta.z j
lda #sprites/$40
sta.z spr_id
__b1:
// sprites_ptr[j] = spr_id++
lda.z spr_id
ldy.z j
sta sprites_ptr,y
// sprites_ptr[j] = spr_id++;
inc.z spr_id
// SPRITES_XPOS[j2] = spr_x
lda.z spr_x
ldy.z j2
sta SPRITES_XPOS,y
// SPRITES_YPOS[j2] = 80
lda #$50
sta SPRITES_YPOS,y
// SPRITES_COLOR[j] = col
lda.z col
ldy.z j
sta SPRITES_COLOR,y
// spr_x = spr_x + 32
lax.z spr_x
axs #-[$20]
stx.z spr_x
// col = col^($7^$5)
lda #7^5
eor.z col
sta.z col
// j2++;
ldx.z j2
inx
inx
stx.z j2
// for( char j : 0..6)
inc.z j
lda #7
cmp.z j
bne __b1
// }
rts
}
gen_sprites: {
.label spr = $f
.label i = $c
lda #<sprites
sta.z spr
lda #>sprites
sta.z spr+1
lda #0
sta.z i
__b1:
// gen_chargen_sprite(cml[i], spr)
ldy.z i
ldx cml,y
lda.z spr
sta.z gen_chargen_sprite.sprite
lda.z spr+1
sta.z gen_chargen_sprite.sprite+1
jsr gen_chargen_sprite
// spr = spr + $40
lda #$40
clc
adc.z spr
sta.z spr
bcc !+
inc.z spr+1
!:
// for( char i : 0..6 )
inc.z i
lda #7
cmp.z i
bne __b1
// }
rts
.segment Data
cml: .text "camelot"
}
.segment Code
// Initialize the PETSCII progress bar
// void progress_init(__zp(3) char *line)
progress_init: {
.label line = 3
// progress_cursor = line
// }
rts
}
// Generate a sine table using BASIC floats
// - sintab is a pointer to the table to fill
// - length is the length of the sine table
// - min is the minimum value of the generated sine
// - max is the maximum value of the generated sine
// void gen_sintab(__zp($13) char *sintab, __zp(9) char length, __zp($11) char min, __register(X) char max)
gen_sintab: {
// amplitude/2
.label f_2pi = $e2e5
.label __20 = $a
.label i = 6
.label min = $11
.label length = 9
.label sintab = $13
// setFAC((unsigned int)max)
txa
sta.z setFAC.w
lda #0
sta.z setFAC.w+1
// 2 * PI
jsr setFAC
// setARGtoFAC()
// fac = max
jsr setARGtoFAC
// setFAC((unsigned int)min)
lda.z min
sta.z setFAC.w
lda #0
sta.z setFAC.w+1
// arg = max
jsr setFAC
// setMEMtoFAC(f_min)
// fac = min
lda #<f_min
sta.z setMEMtoFAC.mem
lda #>f_min
sta.z setMEMtoFAC.mem+1
jsr setMEMtoFAC
// subFACfromARG()
// f_min = min
jsr subFACfromARG
// setMEMtoFAC(f_amp)
// fac = max - min
lda #<f_amp
sta.z setMEMtoFAC.mem
lda #>f_amp
sta.z setMEMtoFAC.mem+1
jsr setMEMtoFAC
// setFAC(2)
// f_amp = max - min
lda #<2
sta.z setFAC.prepareMEM1_mem
lda #>2
sta.z setFAC.prepareMEM1_mem+1
jsr setFAC
// divMEMbyFAC(f_amp)
// fac = 2
lda #<f_amp
sta.z divMEMbyFAC.mem
lda #>f_amp
sta.z divMEMbyFAC.mem+1
jsr divMEMbyFAC
// setMEMtoFAC(f_amp)
// fac = (max - min) / 2
lda #<f_amp
sta.z setMEMtoFAC.mem
lda #>f_amp
sta.z setMEMtoFAC.mem+1
jsr setMEMtoFAC
// addMEMtoFAC(f_min)
// f_amp = (max - min) / 2
jsr addMEMtoFAC
// setMEMtoFAC(f_min)
// fac = min + (max - min) / 2
lda #<f_min
sta.z setMEMtoFAC.mem
lda #>f_min
sta.z setMEMtoFAC.mem+1
jsr setMEMtoFAC
lda #0
sta.z progress_idx
sta.z i
// f_min = min + (max - min) / 2
__b1:
// for(char i =0; i<length; i++)
lda.z i
cmp.z length
bcc __b2
// }
rts
__b2:
// setFAC((unsigned int)i)
lda.z i
sta.z setFAC.w
lda #0
sta.z setFAC.w+1
jsr setFAC
// mulFACbyMEM(f_2pi)
// fac = i
lda #<f_2pi
sta.z mulFACbyMEM.mem
lda #>f_2pi
sta.z mulFACbyMEM.mem+1
jsr mulFACbyMEM
// setMEMtoFAC(f_i)
// fac = i * 2 * PI
lda #<f_i
sta.z setMEMtoFAC.mem
lda #>f_i
sta.z setMEMtoFAC.mem+1
jsr setMEMtoFAC
// setFAC((unsigned int)length)
lda.z length
sta.z setFAC.w
lda #0
sta.z setFAC.w+1
// f_i = i * 2 * PI
jsr setFAC
// divMEMbyFAC(f_i)
// fac = length
lda #<f_i
sta.z divMEMbyFAC.mem
lda #>f_i
sta.z divMEMbyFAC.mem+1
jsr divMEMbyFAC
// sinFAC()
// fac = i * 2 * PI / length
jsr sinFAC
// mulFACbyMEM(f_amp)
// fac = sin( i * 2 * PI / length )
lda #<f_amp
sta.z mulFACbyMEM.mem
lda #>f_amp
sta.z mulFACbyMEM.mem+1
jsr mulFACbyMEM
// addMEMtoFAC(f_min)
// fac = sin( i * 2 * PI / length ) * (max - min) / 2
jsr addMEMtoFAC
// getFAC()
jsr getFAC
// sintab[i] = (char)getFAC()
// fac = sin( i * 2 * PI / length ) * (max - min) / 2 + min + (max - min) / 2
lda.z __20
ldy.z i
sta (sintab),y
// progress_inc()
jsr progress_inc
// for(char i =0; i<length; i++)
inc.z i
jmp __b1
.segment Data
f_i: .byte 0, 0, 0, 0, 0
// i * 2 * PI
f_min: .byte 0, 0, 0, 0, 0
// amplitude/2 + min
f_amp: .byte 0, 0, 0, 0, 0
}
.segment Code
// Generate a sprite from a C64 CHARGEN character (by making each pixel 3x3 pixels large)
// - c is the character to generate
// - sprite is a pointer to the position of the sprite to generate
// void gen_chargen_sprite(__register(X) char ch, __zp(3) char *sprite)
gen_chargen_sprite: {
.label __0 = $a
.label __14 = $a
.label sprite = 3
.label chargen = $a
.label bits = 6
// current sprite char
.label s_gen = 2
.label x = 5
.label y = 9
// Find the current chargen pixel (c)
.label c = 8
// ((unsigned int)ch)*8
txa
sta.z __14
lda #0
sta.z __14+1
asl.z __0
rol.z __0+1
asl.z __0
rol.z __0+1
asl.z __0
rol.z __0+1
// char* chargen = CHARGEN+((unsigned int)ch)*8
lda.z chargen
clc
adc #<CHARGEN
sta.z chargen
lda.z chargen+1
adc #>CHARGEN
sta.z chargen+1
// asm
sei
// *PROCPORT = $32
lda #$32
sta.z PROCPORT
lda #0
sta.z y
__b1:
// char bits = chargen[y]
// current chargen line
ldy.z y
lda (chargen),y
sta.z bits
lda #0
sta.z x
tay
sta.z s_gen
__b2:
// bits & $80
lda #$80
and.z bits
// if((bits & $80) != 0)
cmp #0
beq __b6
lda #1
sta.z c
jmp __b3
__b6:
lda #0
sta.z c
__b3:
ldx #0
// generate 3 pixels in the sprite char (s_gen)
__b4:
// s_gen*2
lda.z s_gen
asl
// s_gen = s_gen*2 | c
ora.z c
sta.z s_gen
// if(++s_gen_cnt==8)
iny
cpy #8
bne __b5
// sprite[0] = s_gen
// sprite char filled - store and move to next char
ldy #0
sta (sprite),y
// sprite[3] = s_gen
ldy #3
sta (sprite),y
// sprite[6] = s_gen
ldy #6
sta (sprite),y
// sprite++;
inc.z sprite
bne !+
inc.z sprite+1
!:
ldy #0
tya
sta.z s_gen
__b5:
// for(char b : 0..2)
inx
cpx #3
bne __b4
// bits = bits*2
asl.z bits
// for(char x:0..7)
inc.z x
lda #8
cmp.z x
bne __b2
// sprite = sprite + 6
lda #6
clc
adc.z sprite
sta.z sprite
bcc !+
inc.z sprite+1
!:
// for(char y:0..7)
inc.z y
lda #8
cmp.z y
bne __b1
// *PROCPORT = $37
lda #$37
sta.z PROCPORT
// asm
cli
// }
rts
}
// FAC = unsigned int
// Set the FAC (floating point accumulator) to the integer value of a 16bit unsigned int
// void setFAC(__zp($f) unsigned int w)
setFAC: {
.label prepareMEM1_mem = $f
.label w = $f
// BYTE0(mem)
lda.z prepareMEM1_mem
// *memLo = BYTE0(mem)
sta.z memLo
// BYTE1(mem)
lda.z prepareMEM1_mem+1
// *memHi = BYTE1(mem)
sta.z memHi
// asm
// Load unsigned int register Y,A into FAC (floating point accumulator)
ldy memLo
jsr $b391
// }
rts
}
// ARG = FAC
// Set the ARG (floating point argument) to the value of the FAC (floating point accumulator)
setARGtoFAC: {
// asm
jsr $bc0f
// }
rts
}
// MEM = FAC
// Stores the value of the FAC to memory
// Stores 5 chars (means it is necessary to allocate 5 chars to avoid clobbering other data using eg. char[] mem = {0, 0, 0, 0, 0};)
// void setMEMtoFAC(__zp($f) char *mem)
setMEMtoFAC: {
.label mem = $f
// BYTE0(mem)
lda.z mem
// *memLo = BYTE0(mem)
sta.z memLo
// BYTE1(mem)
lda.z mem+1
// *memHi = BYTE1(mem)
sta.z memHi
// asm
ldx memLo
tay
jsr $bbd4
// }
rts
}
// FAC = ARG-FAC
// Set FAC to ARG minus FAC
subFACfromARG: {
// asm
jsr $b853
// }
rts
}
// FAC = MEM/FAC
// Set FAC to MEM (float saved in memory) divided by FAC (float accumulator)
// Reads 5 chars from memory
// void divMEMbyFAC(__zp($a) char *mem)
divMEMbyFAC: {
.label mem = $a
// BYTE0(mem)
lda.z mem
// *memLo = BYTE0(mem)
sta.z memLo
// BYTE1(mem)
lda.z mem+1
// *memHi = BYTE1(mem)
sta.z memHi
// asm
lda memLo
ldy memHi
jsr $bb0f
// }
rts
}
// FAC = MEM+FAC
// Set FAC to MEM (float saved in memory) plus FAC (float accumulator)
// Reads 5 chars from memory
// void addMEMtoFAC(char *mem)
addMEMtoFAC: {
// *memLo = BYTE0(mem)
lda #<gen_sintab.f_min
sta.z memLo
// *memHi = BYTE1(mem)
lda #>gen_sintab.f_min
sta.z memHi
// asm
lda memLo
ldy memHi
jsr $b867
// }
rts
}
// FAC = MEM*FAC
// Set FAC to MEM (float saved in memory) multiplied by FAC (float accumulator)
// Reads 5 chars from memory
// void mulFACbyMEM(__zp($a) char *mem)
mulFACbyMEM: {
.label mem = $a
// BYTE0(mem)
lda.z mem
// *memLo = BYTE0(mem)
sta.z memLo
// BYTE1(mem)
lda.z mem+1
// *memHi = BYTE1(mem)
sta.z memHi
// asm
lda memLo
ldy memHi
jsr $ba28
// }
rts
}
// FAC = sin(FAC)
// Set FAC to sine of the FAC - sin(FAC)
// Sine is calculated on radians (0-2*PI)
sinFAC: {
// asm
jsr $e26b
// }
rts
}
// unsigned int = FAC
// Get the value of the FAC (floating point accumulator) as an integer 16bit unsigned int
// Destroys the value in the FAC in the process
getFAC: {
.label return = $a
// asm
// Load FAC (floating point accumulator) integer part into unsigned int register Y,A
jsr $b1aa
sty memLo
sta memHi
// unsigned int w = MAKEWORD( *memHi, *memLo )
sta.z return+1
tya
sta.z return
// }
rts
}
// Increase PETSCII progress one bit
// Done by increasing the character until the idx is 8 and then moving to the next char
progress_inc: {
// if(++progress_idx==8)
inc.z progress_idx
lda #8
cmp.z progress_idx
bne __b1
// *progress_cursor = progress_chars[8]
lda progress_chars+8
ldy #0
sta (progress_cursor),y
// progress_cursor++;
inc.z progress_cursor
bne !+
inc.z progress_cursor+1
!:
lda #0
sta.z progress_idx
__b1:
// *progress_cursor = progress_chars[progress_idx]
ldy.z progress_idx
lda progress_chars,y
ldy #0
sta (progress_cursor),y
// }
rts
.segment Data
// Progress characters
progress_chars: .byte $20, $65, $74, $75, $61, $f6, $e7, $ea, $e0
}
sintab_x: .fill $dd, 0
sintab_y: .fill $c5, 0
|
/* ====================================================================
* The Vovida Software License, Version 1.0
*
* Copyright (c) 2000 Vovida Networks, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The names "VOCAL", "Vovida Open Communication Application Library",
* and "Vovida Open Communication Application Library (VOCAL)" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact vocal@vovida.org.
*
* 4. Products derived from this software may not be called "VOCAL", nor
* may "VOCAL" appear in their name, without prior written
* permission of Vovida Networks, Inc.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
* NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL VOVIDA
* NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
* IN EXCESS OF $1,000, NOR FOR ANY 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.
*
* ====================================================================
*
* This software consists of voluntary contributions made by Vovida
* Networks, Inc. and many individuals on behalf of Vovida Networks,
* Inc. For more information on Vovida Networks, Inc., please see
* <http://www.vovida.org/>.
*
*/
static const char* const SipMimeVersion_cxx_Version =
"$Id: SipMimeVersion.cxx,v 1.3 2004/11/19 01:54:38 greear Exp $";
#include "global.h"
#include "symbols.hxx"
#include "SipMimeVersion.hxx"
#include "SipParserMode.hxx"
using namespace Vocal;
string
SipMimeVersionParserException::getName( void ) const
{
return "SipMimeVersionParserException";
}
SipMimeVersion::SipMimeVersion( const Data& data, const string& local_ip ) //TODO
: SipHeader(local_ip)
{
if (data == "") {
return;
}
try
{
decode(data);
}
catch (SipMimeVersionParserException& exception)
{
if (SipParserMode::sipParserMode())
{
cpLog(LOG_ERR, "Failed to Decode SipMimeVersion : ( ");
throw SipMimeVersionParserException(
exception.getDescription(),
__FILE__,
__LINE__, DECODE_MIMEVERSION_FAILED
);
}
}
}
const SipMimeVersion&
SipMimeVersion::operator=(const SipMimeVersion& src)
{
if (&src != this)
{
value = src.value;
}
return (*this);
}
void SipMimeVersion::decode(const Data& data)
{
Data nData = data;
try
{
scanSipMimeVersion(nData);
}
catch (SipMimeVersionParserException e)
{
if (SipParserMode::sipParserMode())
{
cpLog(LOG_ERR, "Failed to Decode in decode() of SipMimeVersion : ( ");
throw SipMimeVersionParserException(
e.getDescription(),
__FILE__,
__LINE__, DECODE_MIMEVERSION_FAILED
);
}
}
}
void
SipMimeVersion::scanSipMimeVersion(const Data &tmpdata)
{
Data newdata = tmpdata ;
Data rdata;
int test = newdata.match(".",&rdata,true);
if (test == FOUND)
{
string DIGIT = "0123456789";
string rsdata = rdata.convertString();
string newsdata = newdata.convertString();
int test1 = rsdata.find_first_not_of(DIGIT);
if (test1 == -1)
{
int test2 = newsdata.find_first_not_of(DIGIT);
if (test2 == -1)
{
set(tmpdata);
}
else
{
if (SipParserMode::sipParserMode())
{
cpLog(LOG_ERR, "Failed in parsing DIGITS for MIME-VERSION : ( ");
throw SipMimeVersionParserException(
"Failed in parsing DIGITS for MIME-VERSION ",
__FILE__,
__LINE__, DECODE_MIMEVERSION_FAILED
);
}
}
}
else
{
if (SipParserMode::sipParserMode())
{
cpLog(LOG_ERR, "Failed in parsing DIGITS for MIME-VERSION : ( ");
throw SipMimeVersionParserException(
"Failed in parsing DIGITS for MIME-VERSION ",
__FILE__,
__LINE__,DECODE_MIMEVERSION_FAILED
);
}
}
}
if (test == NOT_FOUND)
{
if (SipParserMode::sipParserMode())
{
cpLog(LOG_ERR, "Failed in parsing DIGITS for MIME-VERSION : ( ");
throw SipMimeVersionParserException(
"Failed in parsing DIGITS for MIME-VERSION ",
__FILE__,
__LINE__, DECODE_MIMEVERSION_FAILED
);
}
}
if (test == FIRST)
{
if (SipParserMode::sipParserMode())
{
cpLog(LOG_ERR, "Failed in parsing DIGITS for MIME-VERSION : ( ");
throw SipMimeVersionParserException(
"Failed in parsing DIGITS for MIME-VERSION ",
__FILE__,
__LINE__, DECODE_MIMEVERSION_FAILED
);
}
}
}
SipMimeVersion::SipMimeVersion( const SipMimeVersion& src )
: SipHeader(src),
value(src.value)
{}
///
Data
SipMimeVersion::get() const
{
return value;
}
///
void
SipMimeVersion::set( Data newValue )
{
if (value.length())
{
value = newValue;
}
}
bool SipMimeVersion::operator ==(const SipMimeVersion& srcmv) const
{
bool equal = false;
equal = (value == srcmv.value);
return equal;
}
Data SipMimeVersion::encode() const
{
Data data;
if (value.length())
{
data = "Mime-Version:";
data += SP;
data += value;
data += CRLF;
}
return data;
}
Sptr<SipHeader>
SipMimeVersion::duplicate() const
{
return new SipMimeVersion(*this);
}
bool
SipMimeVersion::compareSipHeader(SipHeader* msg) const
{
SipMimeVersion* otherMsg = dynamic_cast<SipMimeVersion*>(msg);
if(otherMsg != 0)
{
return (*this == *otherMsg);
}
else
{
return false;
}
}
|
/**
* @file compiler.cpp
* @author Marek Sedlacek
* @date July 2021
* @copyright Copyright 2021 Marek Sedlacek. All rights reserved.
*
* @brief Abstract data for all processing units
*
* Every input processing unit should extend processor class
* so that all needed information and methods are present in it.
*/
#include <cstdlib>
#include <iostream>
#include "compiler.hpp"
#include "exceptions.hpp"
#include "logging.hpp"
#include "arg_parser.hpp"
namespace Error {
namespace Colors {
const char * NO_COLOR="\033[0m";
const char * BLACK="\033[0;30m";
const char * GRAY="\033[1;30m";
const char * RED="\033[0;31m";
const char * LIGHT_RED="\033[1;31m";
const char * GREEN="\033[0;32m";
const char * LIGHT_GREEN="\033[1;32m";
const char * BROWN="\033[0;33m";
const char * YELLOW="\033[1;33m";
const char * BLUE="\033[0;34m";
const char * LIGHT_BLUE="\033[1;34m";
const char * PURPLE="\033[0;35m";
const char * LIGHT_PURPLE="\033[1;35m";
const char * CYAN="\033[0;36m";
const char * LIGHT_CYAN="\033[1;36m";
const char * LIGHT_GRAY="\033[0;37m";
const char * WHITE="\033[1;37m";
const char * RESET = "\033[39m";
}
}
const char *Error::get_code_name(Error::ErrorCode code){
const char *NAMES[] = {
"None",
"Unknown",
"Internal",
"File access",
"Arguments",
"Syntactic",
"Semantic",
"Unimplemented",
"Runtime",
"Version"
};
constexpr int names_size = sizeof(NAMES)/sizeof(char *);
if(static_cast<int>(code) < names_size){
return NAMES[static_cast<int>(code)];
}
return "Unknown";
}
void Error::error(Error::ErrorCode code, const char *msg, Exception::EbeException *exc, bool exit){
if(!Args::arg_opts.no_error_print) {
std::cerr << Error::Colors::colorize(Error::Colors::RED) << "ERROR" << Error::Colors::reset()
<< " (" << Error::get_code_name(code);
if(exc == nullptr) {
std::cerr << "): " << msg << "." << std::endl;
}
else {
std::cerr << ", " << exc->get_type() << "): " << msg << ". " << exc->what() << "." << std::endl;
}
}
if(exit){
Error::exit(code);
}
}
void Error::warning(const char *msg) {
if(!Args::arg_opts.no_warn_print) {
std::cerr << Colors::colorize(Colors::PURPLE) << "WARNING: " << Colors::reset() << msg << "." << std::endl;
}
}
void Compiler::error(Error::ErrorCode code, const char *file,
long line, long column, const char *msg,
Exception::EbeException *exc, bool exit){
if(!Args::arg_opts.no_error_print) {
if(file) {
// Dont print name if it is nullptr
std::cerr << file;
if(line < 0) {
std::cerr << ":";
}
}
if(line >= 0){
std::cerr << ":" << line;
if(column >= 0) {
std::cerr << ":" << column;
}
std::cerr << ":";
}
#ifdef DEVELOPER
std::cerr << "[" << unit_name << "]: ";
#endif
std::cerr << Error::Colors::colorize(Error::Colors::RED) << "ERROR "
<< Error::Colors::reset() << "(" << Error::get_code_name(code);
if(exc == nullptr) {
std::cerr << "): " << msg << "." << std::endl;
}
else {
std::cerr << ", " << exc->get_type() << "): " << msg << ". " << exc->what() << "." << std::endl;
}
}
if(exit){
Error::exit(code);
}
}
[[noreturn]] void Error::exit(Error::ErrorCode code) {
LOG1("Exiting program with code " << code);
std::exit(code);
}
Compiler::Compiler(const char *unit_name) : unit_name{unit_name} {
}
|
#include "config.h"
#include "softoff.hpp"
#include "libpldm/entity.h"
#include "libpldm/platform.h"
#include "libpldm/requester/pldm.h"
#include "libpldm/state_set.h"
#include "common/utils.hpp"
#include <sdbusplus/bus.hpp>
#include <sdeventplus/clock.hpp>
#include <sdeventplus/exception.hpp>
#include <sdeventplus/source/io.hpp>
#include <sdeventplus/source/time.hpp>
#include <array>
#include <iostream>
namespace pldm
{
using namespace sdeventplus;
using namespace sdeventplus::source;
constexpr auto clockId = sdeventplus::ClockId::RealTime;
using Clock = Clock<clockId>;
using Timer = Time<clockId>;
constexpr pldm::pdr::TerminusID TID = 0; // TID will be implemented later.
namespace sdbusRule = sdbusplus::bus::match::rules;
SoftPowerOff::SoftPowerOff(sdbusplus::bus::bus& bus, sd_event* event) :
bus(bus), timer(event)
{
getHostState();
if (hasError || completed)
{
return;
}
auto rc = getEffecterID();
if (completed)
{
std::cerr
<< "pldm-softpoweroff: effecter to initiate softoff not found \n";
return;
}
else if (rc != PLDM_SUCCESS)
{
hasError = true;
return;
}
rc = getSensorInfo();
if (rc != PLDM_SUCCESS)
{
std::cerr << "Message get Sensor PDRs error. PLDM "
"error code = "
<< std::hex << std::showbase << rc << "\n";
hasError = true;
return;
}
// Matches on the pldm StateSensorEvent signal
pldmEventSignal = std::make_unique<sdbusplus::bus::match_t>(
bus,
sdbusRule::type::signal() + sdbusRule::member("StateSensorEvent") +
sdbusRule::path("/xyz/openbmc_project/pldm") +
sdbusRule::interface("xyz.openbmc_project.PLDM.Event"),
std::bind(std::mem_fn(&SoftPowerOff::hostSoftOffComplete), this,
std::placeholders::_1));
}
int SoftPowerOff::getHostState()
{
try
{
pldm::utils::PropertyValue propertyValue =
pldm::utils::DBusHandler().getDbusPropertyVariant(
"/xyz/openbmc_project/state/host0", "CurrentHostState",
"xyz.openbmc_project.State.Host");
if ((std::get<std::string>(propertyValue) !=
"xyz.openbmc_project.State.Host.HostState.Running") &&
(std::get<std::string>(propertyValue) !=
"xyz.openbmc_project.State.Host.HostState.TransitioningToOff"))
{
// Host state is not "Running", this app should return success
completed = true;
return PLDM_SUCCESS;
}
}
catch (const std::exception& e)
{
std::cerr << "PLDM host soft off: Can't get current host state.\n";
hasError = true;
return PLDM_ERROR;
}
return PLDM_SUCCESS;
}
void SoftPowerOff::hostSoftOffComplete(sdbusplus::message::message& msg)
{
pldm::pdr::TerminusID msgTID;
pldm::pdr::SensorID msgSensorID;
pldm::pdr::SensorOffset msgSensorOffset;
pldm::pdr::EventState msgEventState;
pldm::pdr::EventState msgPreviousEventState;
// Read the msg and populate each variable
msg.read(msgTID, msgSensorID, msgSensorOffset, msgEventState,
msgPreviousEventState);
if (msgSensorID == sensorID && msgSensorOffset == sensorOffset &&
msgEventState == PLDM_SW_TERM_GRACEFUL_SHUTDOWN)
{
// Receive Graceful shutdown completion event message. Disable the timer
auto rc = timer.stop();
if (rc < 0)
{
std::cerr << "PLDM soft off: Failure to STOP the timer. ERRNO="
<< rc << "\n";
}
// This marks the completion of pldm soft power off.
completed = true;
}
}
int SoftPowerOff::getEffecterID()
{
auto& bus = pldm::utils::DBusHandler::getBus();
// VMM is a logical entity, so the bit 15 in entity type is set.
pdr::EntityType entityType = PLDM_ENTITY_VIRTUAL_MACHINE_MANAGER | 0x8000;
try
{
std::vector<std::vector<uint8_t>> VMMResponse{};
auto VMMMethod = bus.new_method_call(
"xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
"xyz.openbmc_project.PLDM.PDR", "FindStateEffecterPDR");
VMMMethod.append(TID, entityType,
(uint16_t)PLDM_STATE_SET_SW_TERMINATION_STATUS);
auto VMMResponseMsg = bus.call(VMMMethod);
VMMResponseMsg.read(VMMResponse);
if (VMMResponse.size() != 0)
{
for (auto& rep : VMMResponse)
{
auto VMMPdr =
reinterpret_cast<pldm_state_effecter_pdr*>(rep.data());
effecterID = VMMPdr->effecter_id;
}
}
else
{
VMMPdrExist = false;
}
}
catch (const sdbusplus::exception::exception& e)
{
std::cerr << "PLDM soft off: Error get VMM PDR,ERROR=" << e.what()
<< "\n";
VMMPdrExist = false;
}
if (VMMPdrExist)
{
return PLDM_SUCCESS;
}
// If the Virtual Machine Manager PDRs doesn't exist, go find the System
// Firmware PDRs.
// System Firmware is a logical entity, so the bit 15 in entity type is set
entityType = PLDM_ENTITY_SYS_FIRMWARE | 0x8000;
try
{
std::vector<std::vector<uint8_t>> sysFwResponse{};
auto sysFwMethod = bus.new_method_call(
"xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
"xyz.openbmc_project.PLDM.PDR", "FindStateEffecterPDR");
sysFwMethod.append(TID, entityType,
(uint16_t)PLDM_STATE_SET_SW_TERMINATION_STATUS);
auto sysFwResponseMsg = bus.call(sysFwMethod);
sysFwResponseMsg.read(sysFwResponse);
if (sysFwResponse.size() == 0)
{
std::cerr
<< "No effecter ID has been found that matches the criteria"
<< "\n";
return PLDM_ERROR;
}
for (auto& rep : sysFwResponse)
{
auto sysFwPdr =
reinterpret_cast<pldm_state_effecter_pdr*>(rep.data());
effecterID = sysFwPdr->effecter_id;
}
}
catch (const sdbusplus::exception::exception& e)
{
std::cerr << "PLDM soft off: Error get system firmware PDR,ERROR="
<< e.what() << "\n";
completed = true;
return PLDM_ERROR;
}
return PLDM_SUCCESS;
}
int SoftPowerOff::getSensorInfo()
{
pldm::pdr::EntityType entityType;
entityType = VMMPdrExist ? PLDM_ENTITY_VIRTUAL_MACHINE_MANAGER
: PLDM_ENTITY_SYS_FIRMWARE;
// The Virtual machine manager/System firmware is logical entity, so bit 15
// need to be set.
entityType = entityType | 0x8000;
try
{
auto& bus = pldm::utils::DBusHandler::getBus();
std::vector<std::vector<uint8_t>> Response{};
auto method = bus.new_method_call(
"xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
"xyz.openbmc_project.PLDM.PDR", "FindStateSensorPDR");
method.append(TID, entityType,
(uint16_t)PLDM_STATE_SET_SW_TERMINATION_STATUS);
auto ResponseMsg = bus.call(method);
ResponseMsg.read(Response);
if (Response.size() == 0)
{
std::cerr
<< "No sensor PDR has been found that matches the criteria"
<< "\n";
return PLDM_ERROR;
}
pldm_state_sensor_pdr* pdr;
for (auto& rep : Response)
{
pdr = reinterpret_cast<pldm_state_sensor_pdr*>(rep.data());
if (!pdr)
{
std::cerr << "Failed to get state sensor PDR.\n";
return PLDM_ERROR;
}
}
sensorID = pdr->sensor_id;
auto compositeSensorCount = pdr->composite_sensor_count;
auto possibleStatesStart = pdr->possible_states;
for (auto offset = 0; offset < compositeSensorCount; offset++)
{
auto possibleStates =
reinterpret_cast<state_sensor_possible_states*>(
possibleStatesStart);
auto setId = possibleStates->state_set_id;
auto possibleStateSize = possibleStates->possible_states_size;
if (setId == PLDM_STATE_SET_SW_TERMINATION_STATUS)
{
sensorOffset = offset;
break;
}
possibleStatesStart +=
possibleStateSize + sizeof(setId) + sizeof(possibleStateSize);
}
}
catch (const sdbusplus::exception::exception& e)
{
std::cerr << "PLDM soft off: Error get State Sensor PDR,ERROR="
<< e.what() << "\n";
return PLDM_ERROR;
}
return PLDM_SUCCESS;
}
int SoftPowerOff::hostSoftOff(sdeventplus::Event& event)
{
constexpr uint8_t effecterCount = 1;
uint8_t mctpEID;
uint8_t instanceID;
mctpEID = pldm::utils::readHostEID();
// Get instanceID
try
{
auto& bus = pldm::utils::DBusHandler::getBus();
auto method = bus.new_method_call(
"xyz.openbmc_project.PLDM", "/xyz/openbmc_project/pldm",
"xyz.openbmc_project.PLDM.Requester", "GetInstanceId");
method.append(mctpEID);
auto ResponseMsg = bus.call(method);
ResponseMsg.read(instanceID);
}
catch (const sdbusplus::exception::exception& e)
{
std::cerr << "PLDM soft off: Error get instanceID,ERROR=" << e.what()
<< "\n";
return PLDM_ERROR;
}
std::array<uint8_t, sizeof(pldm_msg_hdr) + sizeof(effecterID) +
sizeof(effecterCount) +
sizeof(set_effecter_state_field)>
requestMsg{};
auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
set_effecter_state_field stateField{
PLDM_REQUEST_SET, PLDM_SW_TERM_GRACEFUL_SHUTDOWN_REQUESTED};
auto rc = encode_set_state_effecter_states_req(
instanceID, effecterID, effecterCount, &stateField, request);
if (rc != PLDM_SUCCESS)
{
std::cerr << "Message encode failure. PLDM error code = " << std::hex
<< std::showbase << rc << "\n";
return PLDM_ERROR;
}
// Open connection to MCTP socket
int fd = pldm_open();
if (-1 == fd)
{
std::cerr << "Failed to connect to mctp demux daemon"
<< "\n";
return PLDM_ERROR;
}
// Add a timer to the event loop, default 30s.
auto timerCallback = [=, this](Timer& /*source*/,
Timer::TimePoint /*time*/) {
if (!responseReceived)
{
std::cerr << "PLDM soft off: ERROR! Can't get the response for the "
"PLDM request msg. Time out!\n"
<< "Exit the pldm-softpoweroff\n";
exit(-1);
}
return;
};
Timer time(event, (Clock(event).now() + std::chrono::seconds{30}),
std::chrono::seconds{1}, std::move(timerCallback));
// Add a callback to handle EPOLLIN on fd
auto callback = [=, this](IO& io, int fd, uint32_t revents) {
if (!(revents & EPOLLIN))
{
return;
}
uint8_t* responseMsg = nullptr;
size_t responseMsgSize{};
auto rc = pldm_recv(mctpEID, fd, request->hdr.instance_id, &responseMsg,
&responseMsgSize);
if (rc)
{
return;
}
std::unique_ptr<uint8_t, decltype(std::free)*> responseMsgPtr{
responseMsg, std::free};
// We've got the response meant for the PLDM request msg that was
// sent out
io.set_enabled(Enabled::Off);
auto response = reinterpret_cast<pldm_msg*>(responseMsgPtr.get());
std::cerr << "Getting the response. PLDM RC = " << std::hex
<< std::showbase
<< static_cast<uint16_t>(response->payload[0]) << "\n";
responseReceived = true;
// Start Timer
using namespace std::chrono;
auto timeMicroseconds =
duration_cast<microseconds>(seconds(SOFTOFF_TIMEOUT_SECONDS));
auto ret = startTimer(timeMicroseconds);
if (ret < 0)
{
std::cerr << "Failure to start Host soft off wait timer, ERRNO = "
<< ret << "Exit the pldm-softpoweroff\n";
exit(-1);
}
else
{
std::cerr << "Timer started waiting for host soft off, "
"TIMEOUT_IN_SEC = "
<< SOFTOFF_TIMEOUT_SECONDS << "\n";
}
return;
};
IO io(event, fd, EPOLLIN, std::move(callback));
// Send PLDM Request message - pldm_send doesn't wait for response
rc = pldm_send(mctpEID, fd, requestMsg.data(), requestMsg.size());
if (0 > rc)
{
std::cerr << "Failed to send message/receive response. RC = " << rc
<< ", errno = " << errno << "\n";
return PLDM_ERROR;
}
// Time out or soft off complete
while (!isCompleted() && !isTimerExpired())
{
try
{
event.run(std::nullopt);
}
catch (const sdeventplus::SdEventError& e)
{
std::cerr
<< "PLDM host soft off: Failure in processing request.ERROR= "
<< e.what() << "\n";
return PLDM_ERROR;
}
}
return PLDM_SUCCESS;
}
int SoftPowerOff::startTimer(const std::chrono::microseconds& usec)
{
return timer.start(usec);
}
} // namespace pldm
|
// See www.openfst.org for extensive documentation on this weighted
// finite-state transducer library.
#include <fst/script/fst-class.h>
#include <fst/script/script-impl.h>
#include <fst/script/shortest-distance.h>
namespace fst {
namespace script {
void ShortestDistance(const FstClass &fst, std::vector<WeightClass> *distance,
const ShortestDistanceOptions &opts) {
ShortestDistanceArgs1 args(fst, distance, opts);
Apply<Operation<ShortestDistanceArgs1>>("ShortestDistance", fst.ArcType(),
&args);
}
void ShortestDistance(const FstClass &ifst, std::vector<WeightClass> *distance,
bool reverse, double delta) {
ShortestDistanceArgs2 args(ifst, distance, reverse, delta);
Apply<Operation<ShortestDistanceArgs2>>("ShortestDistance", ifst.ArcType(),
&args);
}
REGISTER_FST_OPERATION(ShortestDistance, StdArc, ShortestDistanceArgs1);
REGISTER_FST_OPERATION(ShortestDistance, LogArc, ShortestDistanceArgs1);
REGISTER_FST_OPERATION(ShortestDistance, Log64Arc, ShortestDistanceArgs1);
REGISTER_FST_OPERATION(ShortestDistance, StdArc, ShortestDistanceArgs2);
REGISTER_FST_OPERATION(ShortestDistance, LogArc, ShortestDistanceArgs2);
REGISTER_FST_OPERATION(ShortestDistance, Log64Arc, ShortestDistanceArgs2);
} // namespace script
} // namespace fst
|
[XCX_CLASSEXPX]
moduleMatches = 0xF882D5CF, 0x30B6E091, 0xAB97DE6B ; 1.0.1E, 1.0.2U, 1.0.1U
.origin = codecave
.int $mod
; ----------------------------------------------------------------------------
; WHO : addClassExpChara__Q2_6Battle14CBattleManagerFUiT1
; WHAT : Multiply the class experience given during combat
_expBattle:
li r12, $mod
mullw r31, r3, r12
blr
; ----------------------------------------------------------------------------
; WHO : addReward__Q2_3cfs11CfSquadUtilSFUiT1
; WHAT : Multiply the experience points given by Squad missions
_expSquadValue:
li r4, $mod
mullw r3, r3, r4
stw r3, 0x18(r1)
blr
_dispBefore:
li r5, $mod
mullw r3, r3, r5
stw r3, 0x34(r1)
blr
; ----------------------------------------------------------------------------
; WHO : menu::MenuMultiQuestResult::setup((void))
; WHAT :
_dispAfter:
li r5, $mod
mullw r3, r3, r5
stw r3, 0x80(r1)
blr
[XCX_CLASSEXPX_1E] ############################################################################
moduleMatches = 0xF882D5CF ; 1.0.1E
0x020C4A28 = bla _expBattle
0x023CC750 = bla _expSquadValue
0x023CC814 = bla _expSquadValue
0x02B91324 = bla _dispBefore
0x02B9FF44 = bla _dispAfter
[XCX_CLASSEXPX_2U] ############################################################################
moduleMatches = 0x30B6E091 ; 1.0.2U
0x020C4A28 = bla _expBattle
0x023CC750 = bla _expSquadValue
0x023CC814 = bla _expSquadValue
0x02B91314 = bla _dispBefore
0x02B9FF34 = bla _dispAfter
[XCX_CLASSEXPX_1U] ############################################################################
moduleMatches = 0xAB97DE6B ; 1.0.1U
0x020C4A28 = bla _expBattle
0x023CC6E0 = bla _expSquadValue
0x023CC7A4 = bla _expSquadValue
0x02B91298 = bla _dispBefore
0x02B9FE44 = bla _dispAfter
|
;
; PC-8801 specific routines
;
; int set_psg(int reg, int val);
;
; Play a sound by PSG
;
;
; $Id: set_psg.asm $
;
SECTION code_clib
PUBLIC set_psg
PUBLIC _set_psg
EXTERN set_psg_callee
EXTERN ASMDISP_SET_PSG_CALLEE
set_psg:
_set_psg:
pop bc
pop de
pop hl
push hl
push de
push bc
jp set_psg_callee + ASMDISP_SET_PSG_CALLEE
|
#include <bits/stdc++.h>
using namespace std;
int check_score (int n0, int n1) {
if (n0 > n1)
swap(n0,n1);
int score;
if (n0 == 1 && n1 == 2)
score = 999999;
else if (n0 == n1)
score = n1*100;
else
score = n1*10 + n0;
return score;
}
int main () {
int s0, s1, r0, r1;
while (scanf("%d %d %d %d",&s0,&s1,&r0,&r1) != EOF) {
if (s0 == 0 && s1 == 0 && r0 == 0 && r1 == 0) break;
int player_1, player_2;
player_1 = check_score(s0,s1);
player_2 = check_score(r0,r1);
if (player_1 == player_2)
printf("Tie.\n");
else if (player_1 > player_2)
printf("Player 1 wins.\n");
else
printf("Player 2 wins.\n");
}
return 0;
}
|
; A183139: a(n) = [1/r]+[2/r]+...+[n/r], where r=sqrt(2) and []=floor.
; 0,1,3,5,8,12,16,21,27,34,41,49,58,67,77,88,100,112,125,139,153,168,184,200,217,235,254,273,293,314,335,357,380,404,428,453,479,505,532,560,588,617,647,678,709,741,774,807,841,876,912,948,985,1023,1061,1100,1140,1181,1222,1264,1307,1350,1394,1439,1484,1530,1577,1625,1673,1722,1772,1822,1873,1925,1978,2031,2085,2140,2195,2251,2308,2365,2423,2482,2542,2602,2663,2725,2787,2850,2914,2979,3044,3110,3177,3244,3312,3381,3451,3521,3592,3664,3736,3809,3883,3957,4032,4108,4185,4262,4340,4419,4498,4578,4659,4741,4823,4906,4990,5074,5159,5245,5331,5418,5506,5595,5684,5774,5865,5956,6048,6141,6235,6329,6424,6520,6616,6713,6811,6909,7008,7108,7209,7310,7412,7515,7618,7722,7827,7933,8039,8146,8254,8362,8471,8581,8692,8803,8915,9028,9141,9255,9370,9485,9601,9718,9836,9954,10073,10193,10313,10434,10556,10679,10802,10926,11051,11176,11302,11429,11556,11684,11813,11943,12073,12204,12336,12468,12601,12735,12870,13005,13141,13278,13415,13553,13692,13832,13972,14113,14255,14397,14540,14684,14828,14973,15119,15266,15413,15561,15710,15859,16009,16160,16312,16464,16617,16771,16925,17080,17236,17392,17549,17707,17866,18025,18185,18346,18507,18669,18832,18996,19160,19325,19491,19657,19824,19992,20160,20329,20499,20670,20841,21013,21186,21359,21533,21708,21884,22060
mov $3,$0
mov $5,$0
lpb $3
mov $0,$5
sub $3,1
sub $0,$3
add $0,1
pow $0,2
mov $2,$0
sub $2,$0
lpb $0
clr $1,1
sub $0,$2
sub $0,1
add $1,2
sub $2,1
add $2,$1
lpe
div $2,2
add $4,$2
lpe
mov $1,$4
|
; ########################################################################################
; # Generated by the active disassembly feature of the Exodus emulation platform
; #
; # Creation Date: 2021-1-5 9:40:29
; # Analysis Region: 0x000038BE - 0x000038DC
; ########################################################################################
org $000038BE
ADDQ.w #2, D6
ADDA.w #$0080, A2
CMPA.w #$E000, A2
BNE.b loc_000038D0
MOVEA.w #$F000, A2 ;Predicted (Code-scan)
BRA.b loc_000038DA ;Predicted (Code-scan)
loc_000038D0:
CMPA.w #0, A2
BNE.b loc_000038DA
MOVEA.w #$DF00, A2 ;Predicted (Code-scan)
loc_000038DA:
MOVE.w D4, D0
|
#include "RRTStar.hpp"
void RRTStar::changeEdge(Tree::Node* parent, Tree::Node* son, Tree::Node* newParent)
{
tree.changeEdge(parent, son, newParent);
}
void RRTStar::getNear(const Geometry::Point& x, std::vector<Tree::Node*>& res)
{
tree.getNear(x, gamma, res);
} |
addi $8,$0,305419896
sw $8, 0($9)
lb $14, 0($9)
lb $15, 1($9)
lb $16, 2($9)
lb $17, 3($9) |
/*=========================================================================
*
* Copyright NumFOCUS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef itkDeformableSimplexMesh3DGradientConstraintForceFilter_hxx
#define itkDeformableSimplexMesh3DGradientConstraintForceFilter_hxx
#include "itkNumericTraits.h"
#include "itkMath.h"
#include "itkMath.h"
#include <set>
namespace itk
{
/* Constructore */
template <typename TInputMesh, typename TOutputMesh>
DeformableSimplexMesh3DGradientConstraintForceFilter<TInputMesh, TOutputMesh>::
DeformableSimplexMesh3DGradientConstraintForceFilter()
{
m_Range = 1;
m_StartVoxel = nullptr;
}
template <typename TInputMesh, typename TOutputMesh>
DeformableSimplexMesh3DGradientConstraintForceFilter<TInputMesh, TOutputMesh>::
~DeformableSimplexMesh3DGradientConstraintForceFilter()
{
this->Clear();
}
template <typename TInputMesh, typename TOutputMesh>
void
DeformableSimplexMesh3DGradientConstraintForceFilter<TInputMesh, TOutputMesh>::PrintSelf(std::ostream & os,
Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "Range = " << m_Range << std::endl;
os << indent << "Image = " << m_Image << std::endl;
}
template <typename TInputMesh, typename TOutputMesh>
void
DeformableSimplexMesh3DGradientConstraintForceFilter<TInputMesh, TOutputMesh>::Clear()
{
delete m_StartVoxel;
m_StartVoxel = nullptr;
std::vector<ImageVoxel *>::iterator it;
for (it = m_Positive.begin(); it != m_Positive.end(); ++it)
{
delete *it;
}
m_Positive.erase(m_Positive.begin(), m_Positive.end());
for (it = m_Negative.begin(); it != m_Negative.end(); ++it)
{
delete *it;
}
m_Negative.erase(m_Negative.begin(), m_Negative.end());
}
template <typename TInputMesh, typename TOutputMesh>
int
DeformableSimplexMesh3DGradientConstraintForceFilter<TInputMesh, TOutputMesh>::Signi(double a)
{
if (a < 0)
{
return -1;
}
else if (a > 0)
{
return 1;
}
else
{
return 0;
}
}
template <typename TInputMesh, typename TOutputMesh>
double
DeformableSimplexMesh3DGradientConstraintForceFilter<TInputMesh, TOutputMesh>::NextVoxel(const double * pp,
int * ic,
double * x,
double * y,
double * z)
{
double d, dlx, dly, dlz;
double dp[3];
dp[0] = pp[0];
dp[1] = pp[1];
dp[2] = pp[2];
if (dp[0] >= 0.0)
{
dlx = ((ic[0] + 1) * 1 - *x) / dp[0];
if (dlx <= 0)
{
dlx = ((ic[0] + 2) * 1 - *x) / dp[0];
}
}
else
{
dlx = (ic[0] * 1 - *x) / dp[0];
if (dlx <= 0)
{
dlx = ((ic[0] - 1) * 1 - *x) / dp[0];
}
}
if (dp[1] >= 0.0)
{
dly = ((ic[1] + 1) * 1 - *y) / dp[1];
if (dly <= 0)
{
dly = ((ic[1] + 2) * 1 - *y) / dp[1];
}
}
else
{
dly = (ic[1] * 1 - *y) / dp[1];
if (dly <= 0)
{
dly = ((ic[1] - 1) * 1 - *y) / dp[1];
}
}
if (dp[2] >= 0.0)
{
dlz = ((ic[2] + 1) * 1 - *z) / dp[2];
if (dlz <= 0)
{
dlz = ((ic[2] + 2) * 1 - *z) / dp[2];
}
}
else
{
dlz = (ic[2] * 1 - *z) / dp[2];
if (dlz <= 0)
{
dlz = ((ic[2] - 1) * 1 - *z) / dp[2];
}
}
if ((dlx < dly) && (dlx < dlz))
{
d = dlx;
ic[0] += this->Signi(dp[0]);
}
else if ((dly < dlz) && (dly < dlx))
{
d = dly;
ic[1] += this->Signi(dp[1]);
}
else
{
d = dlz;
ic[2] += this->Signi(dp[2]);
}
*x += pp[0] * d;
*y += pp[1] * d;
*z += pp[2] * d;
return d;
}
template <typename TInputMesh, typename TOutputMesh>
void
DeformableSimplexMesh3DGradientConstraintForceFilter<TInputMesh, TOutputMesh>::ComputeExternalForce(
SimplexMeshGeometry * data,
const GradientImageType * gradientImage)
{
PointType vec_for;
// image coordinate
int ic[3];
GradientIndexType coord;
double x, y, z;
coord[0] = static_cast<ImageIndexValueType>(data->pos[0]);
coord[1] = static_cast<ImageIndexValueType>(data->pos[1]);
coord[2] = static_cast<ImageIndexValueType>(data->pos[2]);
const OriginalImageType::PointType & orgn = m_Image->GetOrigin();
const OriginalImageType::SpacingType & sp = m_Image->GetSpacing();
if (m_StartVoxel)
{
this->Clear();
}
OriginalImageIndexType index;
// ***keep in mind to add direction cosines in here once we have them
x = data->pos[0] - orgn[0];
y = data->pos[1] - orgn[1];
z = data->pos[2] - orgn[2];
// need to divide by image spacing if it was not one
ic[0] = static_cast<ImageIndexValueType>(x / sp[0]);
ic[1] = static_cast<ImageIndexValueType>(y / sp[1]);
ic[2] = static_cast<ImageIndexValueType>(z / sp[2]);
if (ic[0] >= 0 && ic[0] < this->m_ImageWidth && ic[1] >= 0 && ic[1] < this->m_ImageHeight && ic[2] >= 0 &&
ic[2] < this->m_ImageDepth)
{
bool stop;
SIDEEnum side = SIDEEnum::BOTH; // make sure you can set half segment as well but for noe
// we just set it to full segment
int vpos[3];
int ii;
double dist;
double dp[3];
double pos[3];
ImageVoxel * current;
vpos[0] = ic[0];
vpos[1] = ic[1];
vpos[2] = ic[2];
if (Math::AlmostEquals(
data->normal[0],
itk::NumericTraits<itk::NumericTraits<SimplexMeshGeometry::CovariantVectorType>::ValueType>::ZeroValue()))
{
dp[0] = 1e-6;
}
else
{
dp[0] = data->normal[0];
}
if (Math::AlmostEquals(
data->normal[1],
itk::NumericTraits<itk::NumericTraits<SimplexMeshGeometry::CovariantVectorType>::ValueType>::ZeroValue()))
{
dp[1] = 1e-6;
}
else
{
dp[1] = data->normal[1];
}
if (Math::AlmostEquals(
data->normal[2],
itk::NumericTraits<itk::NumericTraits<SimplexMeshGeometry::CovariantVectorType>::ValueType>::ZeroValue()))
{
dp[2] = 1e-6;
}
else
{
dp[2] = data->normal[2];
}
index[0] = ic[0];
index[1] = ic[1];
index[2] = ic[2];
pos[0] = data->pos[0];
pos[1] = data->pos[1];
pos[2] = data->pos[2];
m_StartVoxel = new ImageVoxel(vpos, pos, static_cast<double>(m_Image->GetPixel(index)), 0.0, 0);
current = new ImageVoxel(vpos, pos, static_cast<double>(m_Image->GetPixel(index)), 0.0, 0);
m_Positive.push_back(current);
// scan normal side
if (side == SIDEEnum::NORMAL || side == SIDEEnum::BOTH)
{
int i = 0;
stop = false;
dist = 0.0;
while (!stop)
{
double a = NextVoxel(dp, ic, &x, &y, &z);
pos[0] += a * dp[0];
pos[1] += a * dp[1];
pos[2] += a * dp[2];
dist += a;
stop = ((dist > m_Range) || !(ic[0] >= 0 && ic[0] < this->m_ImageWidth && ic[1] >= 0 &&
ic[1] < this->m_ImageHeight && ic[2] >= 0 && ic[2] < this->m_ImageDepth));
if (!stop)
{
vpos[0] = ic[0];
vpos[1] = ic[1];
vpos[2] = ic[2];
index[0] = ic[0];
index[1] = ic[1];
index[2] = ic[2];
current = new ImageVoxel(vpos, pos, static_cast<double>(m_Image->GetPixel(index)), dist, ++i);
m_Positive.push_back(current);
if (current->GetDistance() > m_Range)
{
stop = true;
}
else
{
stop = false;
}
}
}
}
// scan inverse normal side
if (side == SIDEEnum::INVERSE || side == SIDEEnum::BOTH)
{
pos[0] = data->pos[0];
pos[1] = data->pos[1];
pos[2] = data->pos[2];
// ***keep in mind to add direction cosines in here once we have them
x = data->pos[0] - orgn[0];
y = data->pos[1] - orgn[1];
z = data->pos[2] - orgn[2];
// need to divide by image spacing if it was not one
ic[0] = static_cast<ImageIndexValueType>(x / sp[0]);
ic[1] = static_cast<ImageIndexValueType>(y / sp[1]);
ic[2] = static_cast<ImageIndexValueType>(z / sp[2]);
dp[0] *= -1.0;
dp[1] *= -1.0;
dp[2] *= -1.0;
ii = 0;
stop = false;
dist = 0.0;
while (!stop)
{
double a = NextVoxel(dp, ic, &x, &y, &z);
pos[0] += a * dp[0];
pos[1] += a * dp[1];
pos[2] += a * dp[2];
dist += a;
stop = ((dist > m_Range) || !(ic[0] >= 0 && ic[0] < this->m_ImageWidth && ic[1] >= 0 &&
ic[1] < this->m_ImageHeight && ic[2] >= 0 && ic[2] < this->m_ImageDepth));
if (!stop)
{
vpos[0] = ic[0];
vpos[1] = ic[1];
vpos[2] = ic[2];
index[0] = ic[0];
index[1] = ic[1];
index[2] = ic[2];
current = new ImageVoxel(vpos, pos, static_cast<double>(m_Image->GetPixel(index)), dist, --ii);
m_Negative.push_back(current);
if (current->GetDistance() > m_Range)
{
stop = true;
}
else
{
stop = false;
}
}
}
}
}
else
{
m_StartVoxel = nullptr;
}
// now fun begins try to use all the above
std::vector<ImageVoxel *>::iterator it;
double mag, max = 0;
GradientIndexType coord3, coord2;
coord2.Fill(0);
for (it = m_Positive.begin(); it != m_Positive.end(); ++it)
{
coord3[0] = static_cast<GradientIndexValueType>((*it)->GetX());
coord3[1] = static_cast<GradientIndexValueType>((*it)->GetY());
coord3[2] = static_cast<GradientIndexValueType>((*it)->GetZ());
const GradientType & gradient3 = gradientImage->GetPixel(coord3);
vec_for[0] = gradient3[0];
vec_for[1] = gradient3[1];
vec_for[2] = gradient3[2];
// check magnitude
mag = std::sqrt(dot_product(vec_for.GetVnlVector(), vec_for.GetVnlVector()));
if (mag > max)
{
max = mag;
coord2 = coord3;
}
}
const GradientType & gradient0 = gradientImage->GetPixel(coord);
const GradientType & gradient2 = gradientImage->GetPixel(coord2);
vec_for[0] = gradient2[0];
vec_for[1] = gradient2[1];
vec_for[2] = gradient2[2];
// now check highest gradient magnitude direction
mag = dot_product(vec_for.GetVnlVector(), data->normal.GetVnlVector());
if (mag > 0)
{
vec_for[0] -= gradient0[0];
vec_for[1] -= gradient0[1];
vec_for[2] -= gradient0[2];
}
else
{
vec_for.Fill(0);
}
data->externalForce[0] = vec_for[0];
data->externalForce[1] = vec_for[1];
data->externalForce[2] = vec_for[2];
}
} // namespace itk
#endif
|
;(address, type, shiftRight, bits, digits, xPos, lineNumber)
%AddStat($7EF458, 1, 0, 32, 4, !FIRST_SWORD_X, !FIRST_SWORD_Y)
%AddStat($7EF45C, 1, 0, 32, 4, !PEGASUS_BOOTS_X, !PEGASUS_BOOTS_Y)
%AddStat($7EF460, 1, 0, 32, 4, !FLUTE_X, !FLUTE_Y)
%AddStat($7EF464, 1, 0, 32, 4, !MIRROR_X, !MIRROR_Y)
%AddStat($7EF452, 0, 4, 04, 2, !SWORDLESS_X, !SWORDLESS_Y)
%AddStat($7EF425, 0, 4, 04, 2, !FIGHTERS_SWORD_X, !FIGHTERS_SWORD_Y)
%AddStat($7EF425, 0, 0, 04, 2, !MASTER_SWORD_X, !MASTER_SWORD_Y)
%AddStat($7EF426, 0, 4, 04, 2, !TEMPERED_SWORD_X, !TEMPERED_SWORD_Y)
%AddStat($7EF426, 0, 0, 04, 2, !GOLD_SWORD_X, !GOLD_SWORD_Y)
%AddStat($7EF42A, 0, 0, 05, 2, !GT_BIG_KEY_X, !GT_BIG_KEY_Y)
%AddStat($7EF420, 0, 0, 08, 3, !BONKS_X, !BONKS_Y)
%AddStat($7EF42D, 0, 0, 08, 2, !SAVE_AND_QUITS_X, !SAVE_AND_QUITS_Y)
%AddStat($7EF449, 0, 0, 08, 2, !DEATHS_X, !DEATHS_Y)
%AddStat($7EF453, 0, 0, 08, 3, !FAERIE_REVIVALS_X, !FAERIE_REVIVALS_Y)
%AddStat($7EF444, 1, 8, 32, 4, !TOTAL_MENU_TIME_X, !TOTAL_MENU_TIME_Y)
%AddStat($7F5038, 1, 0, 32, 4, !TOTAL_LAG_TIME_X, !TOTAL_LAG_TIME_Y)
%AddStat($7EF423, 0, 0, 10, 3, !COLLECTION_RATE_X, !COLLECTION_RATE_Y)
%AddStat($7EF43E, 1, 0, 32, 4, !TOTAL_TIME_X, !TOTAL_TIME_Y) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.