TEST(gogame_move_check, single_piece_surrounded) {
uint8_t board_size = 3;
GoBoard test_board(board_size);
test_board.board[0][1] = get_mask(1);
test_board.board[2][1] = get_mask(1);
test_board.board[1][0] = get_mask(1);
test_board.board[1][2] = get_mask(1);
GoMove test_move(test_board, XYCoordinate(1, 1));
EXPECT_EQ(0, test_move.check_move(0));
}
main()
{
unsigned int m[5] ;
int i, ii ;
for ( i = 0 ; i < 5*32 ; i++ ) {
for ( ii = 0 ; ii < 5 ; ii++ ) {
m[ii] = 0xffffffff ;
}
reset_mask( m, i ) ;
for ( ii = 4 ; ii >= 0 ; ii-- ) {
printf(" %08x ", m[ii]) ;
}
printf("\n") ;
}
for ( i = 0 ; i < 5*32 ; i++ ) {
for ( ii = 0 ; ii < 5 ; ii++ ) {
m[ii] = 0x0 ;
}
set_mask( m, i ) ;
for ( ii = 4 ; ii >= 0 ; ii-- ) {
printf(" %08x ", m[ii]) ;
}
printf("\n") ;
}
for ( ii = 0 ; ii < 5 ; ii++ ) {
m[ii] = 0x0 ;
}
set_mask( m, 82 ) ;
for ( i = 0 ; i < 5*32 ; i++ ) {
printf("%d %0d\n",i,get_mask(m,i) ) ;
}
}
// for each given core-mask extract all required pu-masks
void extract_pu_affinities(hwloc_topology const& t,
std::vector<spec_type> const& specs, std::size_t socket,
std::vector<mask_info> const& core_masks,
std::vector<mask_type>& affinities, error_code& ec)
{
// get the core masks for each of the sockets
for (mask_info const& cmi : core_masks)
{
if (get_index(cmi) == std::size_t(-1))
{
// all cores
if (specs[2].type_ == spec_type::unknown)
{
// no pu information
affinities.push_back(get_mask(cmi));
}
else
{
// handle pu information in the absence of core information
std::vector<mask_info> pu_masks = extract_pu_masks(
t, specs[2], socket, std::size_t(-1),
get_mask(cmi), ec);
if (ec) break;
for (mask_info const& pmi : pu_masks)
{
affinities.push_back(get_mask(pmi));
}
}
break;
}
else
{
// just this core
std::vector<mask_info> pu_masks = extract_pu_masks(
t, specs[2], socket, get_index(cmi), get_mask(cmi), ec);
if (ec) break;
for (mask_info const& pmi : pu_masks)
{
affinities.push_back(get_mask(pmi));
}
}
}
}
//{{{void generate_interval_sets(struct interval *A,
// must run init_genrand(seed) first
void generate_interval_sets(struct interval *A,
unsigned int size_A,
unsigned int len_A,
struct interval *B,
unsigned int size_B,
unsigned int len_B,
unsigned int P)
{
int i;
for (i = 0; i < size_A; i++) {
A[i].start = genrand_int32();
A[i].end = A[i].start + len_A;
}
qsort(A, size_A, sizeof(struct interval), compare_interval_by_start);
/*
* Draw a number to see if the next interval will intersect or not.
* Draw a number to get the next interval, make new interval intersect or
* not with the drawn interval based on the first draw.
*/
int p_max = 100;
unsigned int p_mask = get_mask(p_max);
unsigned int i_mask = get_mask(size_A);
unsigned int l_mask = get_mask(len_A);
for (i = 0; i < size_B; i++) {
unsigned int next_i = get_rand(size_A, i_mask);
unsigned int next_p = get_rand(p_max, p_mask);
if (P >= next_p) // intersect
// Pick an rand between start and end to start from
B[i].start = A[next_i].start + get_rand(len_A, l_mask);
else // do not intersect
B[i].start = A[next_i].end + get_rand(len_A, l_mask);
B[i].end = B[i].start + len_B;
}
}
int vehicle_det::init(int argc, char ** argv)
{
cout << __PRETTY_FUNCTION__ << endl;
/* Background Subtraction Algorithm */
//IBGS * bgs;
//bgs = new PixelBasedAdaptiveSegmenter;
//BackgroundSubtractorMOG2 *bgs=new BackgroundSubtractorMOG2(200, 25, false);
/* Open video file */
vehicle_det::MAX_VEH_DENSITY = 30;
vehicle_det::veh_score_red_rate = 5.0;
cap.open(argv[1]);
if(!cap.isOpened())
{
std::cerr << "Cannot open video!" << std::endl;
return -1;
}
cap.set(CV_CAP_PROP_FRAME_WIDTH, 320);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, 240);
if(!cascade.load("data/veh.xml"))
{
printf("xml file not loaded");
return -1;
}
if(argc >= 4)
{
width_roi = atoi(argv[2]);
height_roi = atoi(argv[3]);
}
if(argc == 5)
{
MAX_VEH_DENSITY = atoi(argv[4]);
}
Mat first_mat;
cap >> first_mat;
min_x = first_mat.cols - 1;
min_y = first_mat.rows - 1;
max_x = 0;
max_y = 0; //initialising the main_roi with default parameters
printf("min_x %d min_y %d\n", min_x, min_y);
define_polygon(first_mat);
mask = get_mask(first_mat);
if(!mask.data)
{
printf("null\n");
}
}
TEST(gogame_move_check, simple_game_1) {
std::vector<XYCoordinate> move_list { {0, 1}, {0, 0}, {1 ,1}, {1, 0}, {2, 1}, {0, 2}, {2, 0}, {1, 2}, {2, 2} };
bool current_color = 0;
uint8_t board_size = 3;
GoGame test(board_size);
for (const XYCoordinate &element : move_list) {
GoMove temp_move(test.get_board(), element);
temp_move.check_move(current_color);
test.make_move(temp_move, current_color);
current_color = !current_color;
}
GoBoard expected(board_size);
expected.board = { {0, 0, get_mask(0)},
{get_mask(0), get_mask(0), get_mask(0)},
{0, 0, get_mask(0)}};
EXPECT_EQ(expected, test.get_board());
}
TEST(gogame_move_check, repeate_moves_history) {
uint8_t board_size = 5;
GoBoard test_board(board_size);
test_board.board[1] = {0, get_mask(0), 0, get_mask(0), 0};
test_board.board[2] = {0, get_mask(1), get_mask(0), get_mask(1), 0};
test_board.board[3][2] = get_mask(1);
GoGame test_game(test_board);
// Make first move
GoMove test_move1(test_game.get_board(), XYCoordinate(0, 2));
test_move1.check_move(0);
test_game.make_move(test_move1, 0);
// Make capture
GoMove test_move2(test_game.get_board(), XYCoordinate(2, 1));
test_move2.check_move(1);
test_game.make_move(test_move2, 1);
// Attempt to make second capture which would reset board to a prior state
GoMove test_move3(test_game.get_board(), XYCoordinate(2, 2));
test_move3.check_move(0);
// Check move is in move history
EXPECT_EQ(true, test_game.check_move_history(test_move3));
}
void set_interface(interface *inter, struct ifaddrs *ifa)
{
get_name(inter,ifa->ifa_name);
get_status(inter,ifa);
if (ifa->ifa_addr->sa_family == AF_INET)
{
get_ipv4(inter,ifa);
get_mask(inter,ifa);
}
if (ifa->ifa_addr->sa_family == AF_INET6)
get_ipv6(inter,ifa);
if (ifa->ifa_addr->sa_family == AF_PACKET)
get_hwaddr(inter,ifa);
}
void initFifo()
{
unsigned int fifoIntMask;
int instrfifosize;
int newhiwatermark;
fifoIntMask = get_mask(DDR, fifo_overflow_status_0)
| get_mask(DDR, fifo_underflow_status_0)
| get_mask(DDR, fifo_finished_status_0)
| get_mask(DDR, fifo_started_status_0)
| get_mask(DDR,fail_int_status_0)
| get_mask(DDR,invalid_opcode_int_status_0)
| get_mask(DDR,warn_int_status_0);
cntrlFifoInit(&ddrFifo_regs, fifoIntMask, get_instrfifosize(DDR));
/* +++++++ set the high and low device-paced FIFO DMA water marks +++++++ */
/* size - headroom equal new high water mark for FIFO DMA device-paced */
/* 8192 - 6 = 8186, so at 8186 words the DMA is told to stop,
/* usually two more words get in */
instrfifosize = getfifosize();
newhiwatermark = instrfifosize - FIFO_HIWATER_MARK_HEADROOM; /* 6 */
setfifohimark(newhiwatermark);
/* setfifolowmark( ..... ); leave as default of 512 or half the instruction FIFO size */
set2ddrfifo();
/* set values in the SW FIFO Control registers to appropriate failsafe values */
/* typically zero, when fail line is assert these values are presented to the output */
/* of the controller, (e.g. high speed gates) Values that need to be serialized */
/* must strobed output by software however. */
/* Greg Brissey 9/16/04 */
preSetAbortStates();
if ((cntrlFifoDmaChan = dmaGetChannel(2)) == -1) {
printf("No dma channel available for FIFO \n");
return;
}
pCntrlFifoBuf = cntlrFifoBufCreate(
DDR_NUM_FIFO_BUFS,
DDR_SIZE_FIFO_BUFS,
cntrlFifoDmaChan,
(volatile unsigned int *) get_pointer(DDR, FIFOInstructionWrite)
);
}
// Searches for the biggest plane where all elements have the
// value $(id) (or don't care)
// In this function itself, there are only initializers to get le mask
// The function deals with the memory issues (saves new plane)
// The real magic takes place in the recursive get_mask function
static char term_plane(plane *p, const char *db, \
const char const *curdb, const int bits, \
const unsigned int count, const int id)
{
if (!((*curdb & 1) == id)) return 0;
// There is going to be a plane, so allocate memory for it
p->next = malloc(sizeof(plane));
p = p->next;
p->next = NULL;
char basemask[bits];
init_mask(basemask, count, bits);
// Give us the best mask with ONES, starting at bit 0
p->psingle = get_mask(db, basemask, bits, id, 0);
return 1;
}
int main (int argc, char* argv[]) {
int min_args = 3;
if (argc < min_args+1) {
printf("need at least %d arguments.\n",min_args);
exit(EXIT_FAILURE);
}
int x, p, n;
x = stoi(argv[1]);
p = stoi(argv[2]);
n = stoi(argv[3]);
printf("starting with %d -> %d\n",x,get_bits(x));
int mask = get_mask(n, p);
printf("generating mask %d\n",get_bits(mask));
int masked_x = x ^ mask;
printf("x after XOR'ing with the mask: %d\n",get_bits(masked_x));
}
/*
* enable all board specific failures interrupts
*/
initialBrdSpecificFailItr()
{
unsigned int failureMask,intMask;
failureMask = get_mask(MASTER,spi_failed_busy0_enable) |
get_mask(MASTER,spi_failed_busy1_enable) |
get_mask(MASTER,spi_failed_busy2_enable);
intMask = get_mask(MASTER,spi_failed_busy0_enable);
DPRINT1(-1,"----------------> Failure Masks: 0x%lx\n",intMask);
fpgaIntConnect( Brd_Specific_Fail_ISR, (HDWAREERROR + MASTER_SPI0_OVRRUN), intMask );
intMask = get_mask(MASTER,spi_failed_busy1_enable);
DPRINT1(-1,"----------------> Failure Masks: 0x%lx\n",intMask);
fpgaIntConnect( Brd_Specific_Fail_ISR, HDWAREERROR + MASTER_SPI1_OVRRUN, intMask );
intMask = get_mask(MASTER,spi_failed_busy2_enable);
DPRINT1(-1,"----------------> Failure Masks: 0x%lx\n",intMask);
fpgaIntConnect( Brd_Specific_Fail_ISR, HDWAREERROR + MASTER_SPI2_OVRRUN, intMask );
cntrlFifoIntrpSetMask(failureMask); /* enable interrupts */
}
void save(const UCHAR* gen, UCHAR* qlt, size_t size)
{ save_x(gen, qlt, size , get_mask()); }
static u16 set_bitfield(u16 val, u16 bits, u16 bit_width, u16 bit_offset)
{
u16 mask = get_mask(bit_width, bit_offset);
val = (val & ~mask) | (bits << bit_offset);
return val;
}
static int
act_disk_fault(str *p_str, led_dtls_t *dtls)
{
return (get_mask(p_str, dtls->n_disks, dtls->faults));
}
static int
act_disk_present(str *p_str, led_dtls_t *dtls)
{
return (get_mask(p_str, dtls->n_disks, dtls->presence));
}
// for each given socket-mask extract all required pu-masks
void extract_core_affinities(hwloc_topology const& t,
std::vector<spec_type> const& specs,
std::vector<mask_info> const& socket_masks,
std::vector<mask_type>& affinities, error_code& ec)
{
// get the core masks for each of the sockets
for (mask_info const& smi : socket_masks)
{
if (get_index(smi) == std::size_t(-1))
{
// all NUMA domains
if (specs[1].type_ == spec_type::unknown)
{
// no core information
if (specs[2].type_ == spec_type::unknown)
{
// no pu information
affinities.push_back(get_mask(smi));
}
else
{
// handle pu information in the absence of core/socket
std::vector<mask_info> pu_masks = extract_pu_masks(
t, specs[2], std::size_t(-1), std::size_t(-1),
get_mask(smi), ec);
if (ec) break;
for (mask_info const& pmi : pu_masks)
{
affinities.push_back(get_mask(pmi));
}
}
}
else
{
// no socket given, assume cores are numbered for whole
// machine
if (specs[2].type_ == spec_type::unknown)
{
// no pu information
std::vector<mask_info> core_masks = extract_core_masks(
t, specs[1], std::size_t(-1), get_mask(smi), ec);
if (ec) break;
for (mask_info const& cmi : core_masks)
{
affinities.push_back(get_mask(cmi));
}
}
else
{
std::vector<mask_info> core_masks = extract_core_masks(
t, specs[1], std::size_t(-1), get_mask(smi), ec);
if (ec) break;
// get the pu masks (i.e. overall affinity masks) for
// all of the core masks
extract_pu_affinities(t, specs, std::size_t(-1),
core_masks, affinities, ec);
if (ec) break;
}
}
break;
}
else
{
std::vector<mask_info> core_masks = extract_core_masks(
t, specs[1], get_index(smi), get_mask(smi), ec);
if (ec) break;
// get the pu masks (i.e. overall affinity masks) for
// all of the core masks
extract_pu_affinities(t, specs, get_index(smi), core_masks,
affinities, ec);
if (ec) break;
}
}
}
static u16 get_bitfield(u16 val, u16 bit_width, u16 bit_offset)
{
u16 mask = get_mask(bit_width, bit_offset);
return (val & mask) >> bit_offset;
}
/*
* @brief: Searches for the biggest plane of $(id)'s and DONTCARES
* @param: char *basemask: The mask where we stem from
* @param: const int bits: How many bits the (char-)bitmask is wide
* @param: char id: Are we looking for ONES or ZEROS
* @param: const int c: From where up we are searching (default=0)
* @return: Pointer to the biggest mask
*/
static char* get_mask(const char *db, const char *basemask, \
const int bits, const char id, const int c)
{
char curc; // We are checking from curc to above
/* Debugging check_mask segv issue
printf("reclvl: %d\n", c);
printf("basemask: ");
printplane(basemask, bits); */
/*We were getting a stackoverflow ... */
// Check the basemask. If it is wrong, return NULL
if (check_mask(db, basemask, id, bits)) {
// It is correct. Check the derivates
char *dermask[bits-c]; // These are the derivates
// The resmask is the ret of the next get_mask()
// It is NULL if there was no good mask, or the best mask found
char *resmask[bits-c];
int i; // counter
for (curc = c, i = 0; curc < bits; curc++, i++) {
// Make the derivate mask
dermask[i] = malloc(bits * sizeof(char)); // Derivate mask
memcpy(dermask[i], basemask, bits * sizeof(char));
dermask[i][curc] = 2;
// Now feed it back to this function recursively
resmask[i] = get_mask(db, dermask[i], bits, id, curc + 1);
}
// We got all the masks we want, so free the dermasks
// Also, check for the best resmask already
char* bestmask = NULL;
int bestscore = 0;
for (i = 0; i < bits - c; i++) {
free(dermask[i]);
// check for the best mask
int score = 0;
if (resmask[i]) score = amount_in_ar(resmask[i], bits, 2);
if (bestscore < score) {
bestscore = score;
// Wait a sec. This one is better, Delete the old one!
if (bestmask) free(bestmask);
// Now replace the dangling pointer with the new hero!
bestmask = resmask[i];
} else {
// No highscore? Delete that crap!
if (resmask[i]) free(resmask[i]);
}
}
/* Debugging here:
if (bestmask && c == 0) {
printf("At level 0: ");
printplane(bestmask, bits);
printf("\n");
}
else if (c == 0) {
printf("At level 0: ");
printplane(basemask, bits);
printf("\n");
}*/
// If there is a winner mask, return it. If not, move on.
if (bestmask) return bestmask;
// The mask is correct, but we didn't find better masks
char *basemask_cp = malloc(bits * sizeof(char));
memcpy(basemask_cp, basemask, bits * sizeof(char));
return basemask_cp;
} /* end check_mask() */
if (c == 0) assert(0); // The first basemask should never fail
return NULL;
}
int main (int argc,char **argv){
FILE *fp = fopen(argv[1], "rb");
FILE *fp2 = fopen("lower.tga", "wb");
FILE *fp3 = fopen("upper.tga", "wb");
int w, h, mask_r,mask_g,mask_b;
long long r=0,g=0,b=0;
//int r_bit=argv[3][0]-48,g_bit=argv[4][0]-48,b_bit=argv[5][0]-48;
//printf("%d %d %d",r_bit,g_bit,b_bit);
int r_bit=3,g_bit=3,b_bit=2;
r_bit=b_bit=g_bit=(argv[2][0]-48);
float mse,mse_r,mse_g,mse_b,snr,snr_r,snr_g,snr_b;
mse_r=mse_g=mse_b=mse=snr=snr_r=snr_g=snr_b=0;
mask_r=get_mask(r_bit);
mask_g=get_mask(g_bit);
mask_b=get_mask(b_bit);
int header[18];
int header2[18];
for (int i =0; i<18 ; i++){
header[i]=getc(fp);
header2[i]=header[i];
}
//pobieranie nagłówka
w = (header[13]<<8)+header[12];
h = (header[15]<<8)+header[14];
for (int i =0; i<18 ; i++){
putc(header2[i],fp2);
putc(header2[i],fp3);
}
int i=0;
int j=0;
int rgb[3];
int rgb_l[3];
int rgb_u[3],rgb_ur[3];
int nrgb[3];
int prgb[3]={0},prgb_u[3]={0};
for (i=0;i<h;i++){
for( j=0;j < w;j++){
if((j%2)==0){
for(int k=0;k<3;k++){
rgb[k]=getc(fp);
int tmp2=rgb[k];
rgb_l[k]=(tmp2+prgb[k])/2;
int tmp=rgb[k];
rgb_u[k]=((unsigned)(tmp-prgb[k])/2);
rgb_ur[k]=rgb_u[k]-prgb_u[k];
}
for(int l=0;l<3;l++) prgb[l]=rgb[l];
for(int l=0;l<3;l++) prgb_u[l]=rgb_u[l];
nrgb[0]=quant(rgb_l[0],mask_r,r_bit);
nrgb[1]=quant(rgb_l[1],mask_g,g_bit);
nrgb[2]=quant(rgb_l[2],mask_b,b_bit);
put3c(nrgb[0],nrgb[1],nrgb[2],fp2);
put3c(rgb_ur[0],rgb_ur[1],rgb_ur[2],fp2);
}else{
for(int i=0;i<3;i++){
getc(fp);
}
}
}
}
int all=w*h;
return 0;
}
UINT32 load(UCHAR* gen, const UCHAR* qlt, size_t size)
{return load_x(gen, qlt, size, get_mask()); }
static int run_psnr(FILE *f[2], int len, int shift, int skip_bytes)
{
int i, j;
uint64_t sse = 0;
double sse_d = 0.0;
uint8_t buf[2][SIZE];
int64_t max = (1LL << (8 * len)) - 1;
int size0 = 0;
int size1 = 0;
uint64_t maxdist = 0;
double maxdist_d = 0.0;
int noseek;
noseek = fseek(f[0], 0, SEEK_SET) ||
fseek(f[1], 0, SEEK_SET);
if (!noseek) {
for (i = 0; i < 2; i++) {
uint8_t *p = buf[i];
if (fread(p, 1, 12, f[i]) != 12)
return 1;
if (!memcmp(p, "RIFF", 4) &&
!memcmp(p + 8, "WAVE", 4)) {
if (fread(p, 1, 8, f[i]) != 8)
return 1;
while (memcmp(p, "data", 4)) {
int s = p[4] | p[5] << 8 | p[6] << 16 | p[7] << 24;
fseek(f[i], s, SEEK_CUR);
if (fread(p, 1, 8, f[i]) != 8)
return 1;
}
} else {
fseek(f[i], -12, SEEK_CUR);
}
}
fseek(f[shift < 0], abs(shift), SEEK_CUR);
fseek(f[0], skip_bytes, SEEK_CUR);
fseek(f[1], skip_bytes, SEEK_CUR);
}
fflush(stdout);
for (;;) {
int s0 = fread(buf[0], 1, SIZE, f[0]);
int s1 = fread(buf[1], 1, SIZE, f[1]);
int tempsize = FFMIN(s0,s1);
DECLARE_ALIGNED(32, FFTComplex, fftcomplexa)[SIZE/len];
DECLARE_ALIGNED(32, FFTComplex, fftcomplexb)[SIZE/len];
for (j = 0; j < tempsize; j += len) {
switch (len) {
case 1:
case 2: {
int64_t a = buf[0][j];
int64_t b = buf[1][j];
int dist;
if (len == 2) {
fftcomplexa[j/len].re = get_s16l(buf[0] + j);
fftcomplexb[j/len].re = get_s16l(buf[1] + j);
fftcomplexa[j/len].im = 0;
fftcomplexb[j/len].im = 0;
} else {
fftcomplexa[j/len].re = buf[0][j];
fftcomplexb[j/len].re = buf[1][j];
fftcomplexa[j/len].im = 0;
fftcomplexb[j/len].im = 0;
}
dist = abs(fftcomplexa[j/len].re-fftcomplexb[j/len].re);
if (dist > maxdist)
maxdist = dist;
break;
break;
}
case 4:
case 8: {
double dist, a, b;
if (len == 8) {
fftcomplexa[j/len].re = (float) get_f64l(buf[0] + j);
fftcomplexb[j/len].re = (float) get_f64l(buf[1] + j);
fftcomplexa[j/len].im = 0;
fftcomplexb[j/len].im = 0;
} else {
fftcomplexa[j/len].re = (float) get_f32l(buf[0] + j);
fftcomplexb[j/len].re = (float) get_f32l(buf[1] + j);
fftcomplexa[j/len].im = 0;
fftcomplexb[j/len].im = 0;
}
dist = abs(fftcomplexa[j/len].re-fftcomplexb[j/len].re);
if (dist > maxdist_d)
maxdist_d = dist;
break;
}
}
}
for(;j<SIZE;j+=len){
fftcomplexa[j/len].re = 0;
fftcomplexb[j/len].re = 0;
fftcomplexa[j/len].im = 0;
fftcomplexb[j/len].im = 0;
}
size0 += s0;
size1 += s1;
if (s0 + s1 <= 0)
break;
FFTContext* fftcontexta = av_fft_init(floor(log2(SIZE/len)),0);
av_fft_permute (fftcontexta, fftcomplexa);
int temp = 0;
av_fft_calc (fftcontexta, fftcomplexa);
FFTContext* fftcontextb = av_fft_init(floor(log2(SIZE/len)),0);
av_fft_permute (fftcontextb, fftcomplexb);
av_fft_calc (fftcontextb, fftcomplexb);
float* maskingfunc = get_mask_array(SIZE/len);
float* mask = get_mask(fftcomplexa, SIZE/len, maskingfunc);
double psysse = get_psy_sse(fftcomplexa,fftcomplexb, mask, SIZE/len);
free(maskingfunc);
free(mask);
sse+=psysse;
sse_d+=psysse;
}
fflush(stdout);
i = FFMIN(size0, size1) / len;
if (!i)
i = 1;
switch (len) {
case 1:
case 2: {
uint64_t psnr;
uint64_t dev = int_sqrt(((sse / i) * F * F) + (((sse % i) * F * F) + i / 2) / i);
if (sse)
psnr = ((2 * log16(max << 16) + log16(i) - log16(sse)) *
284619LL * F + (1LL << 31)) / (1LL << 32);
else
psnr = 1000 * F - 1; // floating point free infinity :)
printf("stddev:%5d.%02d PSYSNR:%3d.%02d MAXDIFF:%5"PRIu64" bytes:%9d/%9d\n",
(int)(dev / F), (int)(dev % F),
(int)(psnr / F), (int)(psnr % F),
maxdist, size0, size1);
return psnr;
}
case 4:
case 8: {
char psnr_str[64];
double psnr = INT_MAX;
double dev = sqrt(sse_d / i);
uint64_t scale = (len == 4) ? (1ULL << 24) : (1ULL << 32);
if (sse_d) {
psnr = 2 * log(DBL_MAX) - log(i / sse_d);
snprintf(psnr_str, sizeof(psnr_str), "%5.02f", psnr);
} else
snprintf(psnr_str, sizeof(psnr_str), "inf");
maxdist = maxdist_d * scale;
printf("stddev:%10.2f PSYSNR:%s MAXDIFF:%10"PRIu64" bytes:%9d/%9d\n",
dev * scale, psnr_str, maxdist, size0, size1);
return psnr;
}
}
return -1;
}
int main(){
int n;
int m;
int next;
int x;
int runs;
scanf("%d",&runs);
while ( runs-- ){
for ( int i=0; i < 10; ++i )
for ( int j=0; j < 10; ++j ){
I[i][j] = -1;
attack[i][j] = false;
}
n = 0;
for ( int i=0; i < 10; ++i ){
scanf("%s",M[i]);
for ( int j=0; j < 10; ++j )
if ( M[i][j] == 'e' ){
I[i][j] = n;
put_value(i,j,true);
n++;
}
}
for ( int i=0; i < 10; ++i )
for ( int j=0; j < 10; ++j )
if ( M[i][j] == 'g' )
put_value(i,j,false);
for ( int i=0; i < 10; ++i)
for ( int j=0; j < 10; ++j )
if ( attack[i][j] )
mask[i][j] = get_mask(i,j);
dp[0] = 0;
for ( int i=1; i < (1<<n); ++i ) dp[i] = INF;
for ( int i=0; i < 10; ++i )
for ( int j=0; j < 10; ++j ){
if ( attack[i][j] ){
for ( int k=(1<<n)-1; k >= 1; --k ){
dp[k] = min( dp[k] , dp[ k & (~mask[i][j]) ] + 1 );
}
}
}
int most = 0;
int t;
int best = 0;
for ( int i=1; i < (1<<n); ++i ){
t = bitcount( i );
if ( t >= most && dp[i] < INF ){
if ( t > most ){ most = t; best = dp[i]; }
else if ( best > dp[i] ) best = dp[i];
}
}
printf("%d %d\n",most,best);
}
return 0;
}
void solve(int lim) {
if ( lim < 10 ) {
if ( TABLE[lim] == -1 )
printf("IMPOSSIBLE\n");
else
printf("%d 1\n", TABLE[lim]);
return;
}
static int dig[12];
int n_dig = 0;
{
int tmp = lim;
while ( tmp ) {
dig[++ n_dig] = tmp % 10, tmp /= 10;
}
}
Matrix res;
bool first = true;
int cur_s = 0, pre_s = 0;
bool pre_nine = false;
for ( int i = n_dig; i >= 2; i -- ) {
if ( i != n_dig )
cur_s |= 1 << dig[i + 1];
if ( first ) {
res = dp(i - 1, cur_s);
pre_nine = i > 2;
first = false;
} else if ( dig[i] != 0 ) {
res = merge(res, dp(i - 1, cur_s), pre_s, pre_nine);
pre_nine = i > 2;
pre_s = cur_s;
}
for ( int j = 1; j < dig[i]; j ++ ) {
res = merge(res, dp(i - 1, cur_s | (1 << j)), pre_s, pre_nine);
pre_nine = i > 2;
pre_s = cur_s | (1 << j);
}
}
int delta;
for ( int i = 2; i <= n_dig; i ++ ) {
if ( dig[i] != 0 ) {
int tmp = 0;
for ( int j = n_dig; j > i; j -- )
tmp = tmp * 10 + dig[j];
tmp = tmp * 10 + dig[i] - 1;
for ( int j = i - 1; j >= 2; j -- )
tmp = tmp * 10 + 9;
tmp *= 10;
delta = tmp;
break;
}
}
Info f[10];
for ( int i = 0; i <= 9; i ++ ) {
Info I = res.ele[1][i];
I.val ++;
int real = delta + i;
int s = get_mask(real);
for ( int x = 1; x <= 9; x ++ )
if ( s & (1 << x) )
if ( x + i >= 10 ) {
f[x + i - 10].update(I);
}
}
for ( int i = 0; delta + 10 + i <= lim; i ++ ) {
int real = delta + 10 + i;
int s = get_mask(real);
Info I = f[i];
I.val ++;
for ( int x = 1; x <= 9; x ++ )
if ( s & (1 << x) )
if ( x + i <= 9 ) {
f[x + i].update(I);
}
}
int des = lim - delta - 10;
if ( f[des].val == inf )
printf("IMPOSSIBLE\n");
else
printf("%d %d\n", f[des].val, f[des].ways);
}
