int main()
{
	int test;
	scanf("%d",&test);
	//printf("%lf\n",sqrt(2.0));
	for(int tt = 1 ; tt <= test ;tt ++)
	{
		for(int i=0;i<4;i++)
		{
			scanf("%lf %lf",&x[i],&y[i]);
		}
		a[0] = 0;
		a[1] = 2;a[2] = 1;a[3] = 3;
		int flag = 0;
		if(pan())flag=1;
		a[0] = 0;
		a[1] = 1;a[2] = 2;a[3] = 3;
		if(pan())flag=1;
		a[0] = 0;
		a[1] = 1 ; a[2] = 3;a[3] = 2;
		if(pan())flag=1;
		if(tt != 1)printf("\n");
		if(flag == 1)
			printf("Case %d:\nYes\n",tt);
		if(flag == 0)
			printf("Case %d:\nNo\n",tt);
	}
}

void WaypointCamera::setOriginTarget(){
    originTarNode.resetTransform();
    originTarNode.setPosition(getPosition());
    pan(-180); // Fix for camera orientation
    originTarNode.setOrientation(getOrientationQuat());
    pan(180); // Fix for camera orientation
}

int main(void)
{
    int f,res,b[300],ji;
    char a[300][20],c[20];
    while(scanf("%s",&a[0])!=EOF)
    {
        strcpy(c,a[0]);
        res=pan(a[0]);
        ji=1;
        for(ji=1;0==res;ji++)
        {
            b[ji]=tod(a[ji-1]);
            fan(a[ji-1]);
            b[ji]=b[ji]+tod(a[ji-1]);
            tos(b[ji],a[ji]);
            res=pan(a[ji]);
        }
        printf("%d\n",ji-1);
        printf("%s",c);
        for(f=1;f<ji;f++)
        {
            printf("--->");
            printf("%s",a[f]);
        }
        printf("\n");
    }
return 0;
}

void Camera::setMotionAdjustment(const QVector3D& vector)
{
    Q_D(Camera);
    if (d->motionAdjustment != vector) {
        d->motionAdjustment = vector;
        if (vector.x() == 0.0f && vector.y() == 0.0f) {
            // If the vector is centered, then don't perform any rotations.
            d->motionQuaternion = QQuaternion();
        } else {
            // Determine the pan and tilt angles from the vector.
            QVector3D view = -vector.normalized();
            if (view.z() < 0.0f)
                view = -view;
            qreal xangle = asin(view.x()) * 180.0f / M_PI;
            qreal yangle = asin(-view.y()) * 180.0f / M_PI;

            // Construct the pan and tilt quaternions.
            if (qFuzzyIsNull(xangle))
                d->motionQuaternion = tilt(yangle);
            else if (qFuzzyIsNull(yangle))
                d->motionQuaternion = pan(xangle);
            else
                d->motionQuaternion = tilt(yangle) * pan(xangle);
        }
        emit viewChanged();
    }
}

int main() {

	ssc_init("/dev/ttyUSB0", 9600);
	pan( 0 );
	tilt( 0 );

	cascade = (CvHaarClassifierCascade*)cvLoad(
		"cascade.xml", 0, 0, 0 );
	if( !cascade )
    {
        fprintf( stderr, "ERROR: Could not load classifier cascade\n" );
        return 1;
    }
	storage = cvCreateMemStorage(0);

	struct camera *cam = init_camera( LCAM );
	load_params( cam );

	cvNamedWindow( "Face", CV_WINDOW_AUTOSIZE );

	CvPoint pt1, pt2;
	CvRect *r;
	CvSeq *faces;
	float multip = 0.1;
	int x_diff, y_diff;

	while( cvWaitKey( 10 ) == -1 ) {

		cap_frame( cam );
		undistort( cam );
		
		cvClearMemStorage( storage );
		faces = cvHaarDetectObjects( cam->undist, cascade, storage,
        	1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(40, 40) );

		if (faces->total > 0) {
;
			r = (CvRect*)cvGetSeqElem( faces, 0 );
			pt1.x = r->x;
			pt2.x = r->x + r->width;
			pt1.y = r->y;
			pt2.y = r->y + r->height;
			cvRectangle( cam->undist, pt1, pt2, CV_RGB(255,0,0), 3, 8, 0 );
			
			x_diff = (cam->frame->width / 2) - (r->x + (r->width/2)) ;
            y_diff = (cam->frame->height / 2) - (r->y + (r->height/2)) ;

            pan( -(int)(x_diff * multip) );
            tilt( (int)(y_diff * multip) );

		}

		cvShowImage( "Face", cam->undist );

	}
	cvDestroyAllWindows();
	cvReleaseMemStorage( &storage );
	free_camera( cam );
}

//------------------------------------------------------------------------------
//!
bool
CameraManipulator::onPointerMove( const Event& ev )
{
   if( _mode == 0 ) return false;

   switch( _mode )
   {
      case 1:
      {
         float radP = CGM::degToRad( _grabPos.x - ev.position().x );
         float radS = CGM::degToRad( ev.position().y - _grabPos.y );
         radP *= _direction;
         if( _isLocked  )
         {
            orbit( radP*0.75f, radS*0.75f );
         }
         else
         {
            tilt( radP*0.25f, radS*0.25f );
         }
         return true;
      } break;
      case 2: forward( ev.position() );
         return true;
      case 3: pan( ev.position() );
         return true;
      default:;
   }
   return false;
}

SDL_Surface *zoom100(SDL_Surface *image, SDL_Rect *pos, double *scale)
{
    SDL_Surface *result = SDL_ConvertSurface(image, image->format, image->flags);
    if (result == (SDL_Surface *) (NULL))
    {
        fprintf(stderr, "\n Error from ConvertSurface()\n\n");
        quit();
    }

    if (*scale < 1.0) {
        pos->x /= *scale;
        pos->y /= *scale;
        pos->x -= SCREENWIDTH * (1-(1 / *scale)) * 0.5;
        pos->y -= SCREENHEIGHT * (1-(1 / *scale)) * 0.5;
    } else {
        pos->x += SCREENWIDTH * (1-*scale) * 0.5;
        pos->y += SCREENHEIGHT * (1-*scale) * 0.5;
        pos->x /= *scale;
        pos->y /= *scale;
    }
    pan(result, pos, 0, 0);
    *scale = 1.0;

    return result;
}

AREXPORT bool ArAMPTU::panTilt_i(double panDeg, double tiltDeg)
{
  if (panDeg > getMaxPosPan_i())
    panDeg = getMaxPosPan_i();
  if (panDeg < getMaxNegPan_i())
    panDeg = getMaxNegPan_i();

  if (tiltDeg > getMaxPosTilt_i())
    tiltDeg = getMaxPosTilt_i();
  if (tiltDeg < getMaxNegTilt_i())
    tiltDeg = getMaxNegTilt_i();

  if (myPan - panDeg == 0 && myTilt - tiltDeg == 0)
    return true;
  if (myPan - panDeg == 0) 
    return tilt(tiltDeg);
  if (myTilt - tiltDeg == 0)
    return pan(panDeg);
  myPan = panDeg;
  myTilt = tiltDeg;



  myPacket.empty();
  myPacket.byteToBuf(ArAMPTUCommands::PANTILT);
  myPacket.byte2ToBuf(ArMath::roundInt(myPan + 
				       (getMaxPosPan_i() - getMaxNegPan_i())/2));
  myPacket.byteToBuf(ArMath::roundInt(myTilt + (getMaxPosTilt_i() - 
						getMaxNegTilt_i())/2));
  return sendPacket(&myPacket);
}

void BassPlayer::playPreproccessing() {
    emit statusChanged(media_title, LoadedMedia);

    BASS_CHANNELINFO info;
    if (BASS_ChannelGetInfo(chan, &info))
        channelsCount(info.chans);
    else
        channelsCount(2);

    if (eq_in_use) registerEQ();

    #ifdef BASS_USE_TEMPO
        applyTempoToChannel();
        newTempoProcessing(tempo());
    #endif

    setSampleRateQuality();
    newVolumeProcessing(volume());
    newPanProcessing(pan());

    if (BASS_ChannelPlay(chan, true)) { // stalled with big sized video files
        playPostprocessing(is_paused);

        syncHandle = BASS_ChannelSetSync((HSYNC)chan, BASS_SYNC_END, 0, &endTrackSync, this);
        syncDownloadHandle = BASS_ChannelSetSync(chan, BASS_SYNC_DOWNLOAD, 0, &endTrackDownloading, this);

//        BASS_SYNC_STALL
//        mixtime only	Sync when playback of the channel is stalled/resumed.
//        param : not used. data : 0 = stalled, 1 = resumed.
    } else {
        proceedErrorState();
        qCritical() << "IS NOT PLAYED";
    }
}

void CommandInterpreter::handleCommand(TACommand command)
{
	XTestGrabControl(display, True);

    printf("COMMAND: %i, %i, %i, %i, %f\n", command.type, command.touch, command.xDifference, command.yDifference, command.zoomValue);
	switch(command.type)
	{		
		case TACommandTypeZoom:
			zoom(command);
			break;
		case TACommandTypePan:
			pan(command);
			break;
		case TACommandTypeRotate:
			rotate(command);
			break;
		default:
		break;
	}
	
	XSync(display, 0);
	
	XTestGrabControl(display, False);
	usleep(100);
}

void Viewport::mouseMoveEvent(QMouseEvent *event)
{
    _dragging = true;
    _current_pos = event->pos();

    QGraphicsView::mouseMoveEvent(event);
    if (scene->mouseGrabberItem() == NULL)
    {
        if (event->buttons() == Qt::LeftButton)
        {
            pan(_click_pos_world - sceneToWorld(mapToScene(event->pos())));
        }
        else if (event->buttons() == Qt::RightButton && !angle_locked)
        {
            QPointF d = _click_pos - event->pos();
            pitch = fmin(0, fmax(-M_PI, pitch - 0.01 * d.y()));
            yaw = fmod(yaw + M_PI - 0.01 * d.x(), M_PI*2) - M_PI;

            _click_pos = event->pos();
            update();
            scene->invalidate(QRect(),QGraphicsScene::ForegroundLayer);
            emit(viewChanged());
        }
    }

    updateInfo();
}

void MdispGtkView::FillDisplay( bool on )
   {
   if(m_MilDisplay)
      {
      // Fill display is incompatible with pan.
      pan( 0, 0 );
      if(on)
         {
         // disable temporary using user's XDisplay
         // filldisplay can generate excessive expose ( paint) event
         // this can freeze main menu window 
         MdispControl(m_MilDisplay,M_WINDOW_ANNOTATIONS,M_NULL);
         }
      else
         {
         MdispControl(m_MilDisplay,M_WINDOW_ANNOTATIONS,M_PTR_TO_DOUBLE(GDK_WINDOW_XDISPLAY(m_window->window)));
         }
      //Using MIL, enable/disable Fill Display Mode [CALL TO MIL]
      MdispControl(m_MilDisplay, M_FILL_DISPLAY, on ? M_ENABLE : M_DISABLE);

      m_isFillDisplayEnabled = on;

      UpdateContentSize();
      }
   }

int main()
{
    int f,i; 
    while(scanf("%d",&nn)!=EOF)
    {
        group=nn; 
        n=2*group; 
        for(i=1;i<=nn;i++)
        {
            for(f=1;f<=nn;f++)
            {
                scanf("%d",&b[i][f]); 
            }
        }

        if(0 == pan())
        {
            printf("NO\n");
            continue;
        }
                
        for(now=1;now<=31;now++)
        {
            chu();        
            for(i=1;i<=nn;i++)
            {
                for(f=i+1;f<=nn;f++)
                {
                    if(i == f)
                    {
                        continue;    
                    } 
                    else if((i%2)==0 && (f%2)==0) 
                    {
                        huo(i,f);
                    }
                    else if((i%2)==1 && (f%2)==1)
                    {
                        yu(i,f); 
                    }
                    else
                    {
                        yihuo(i,f);        
                    } 
                }
            }
            slove();
            if(0 == check())
            {
                printf("NO\n"); 
                break;
            }
        }
        if(32 == now)
        {
            printf("YES\n");
        }
    } 
    return 0;
}

    void QuatTrackBall::roll_ball(const Vec2i& v)
    {
        if(v[0] < 0 || v[0] >= static_cast<int>(width)
           || v[1] < 0 || v[1] >= static_cast<int>(height))
            return;
        
        Vec2f w = scalePoint(v);
        
        switch (current_action)
        {
			case ROTATE_ACTION:
                rotate(w);
                break;
                
			case PAN_ACTION:
                pan(w);
                break;
                
			case ZOOM_ACTION:
                zoom(w);
                break;
            case NO_ACTION:
            default:
                break;
        }
        last_pos = w;
    }

static int
checkmouse(void)	/* return button touched if any */
{
	int c, b;
	char *p;
	extern int confirm(int);

	b = waitdown();
	last_but = 0;
	last_hit = -1;
	c = 0;
	if (button3(b)) {
		last_hit = emenuhit(3, &mouse, &mbut3);
		last_but = 3;
	} else if (button2(b)) {
		last_hit = emenuhit(2, &mouse, &mbut2);
		last_but = 2;
	} else {		/* button1() */
		pan();
		last_but = 1;
	}
	waitup();
	if (last_but == 3 && last_hit >= 0) {
		p = m3[last_hit];
		c = p[strlen(p) - 1];
	}
	if (c == '?' && !confirm(last_but))
		last_hit = -1;
	return last_but;
}

void DisplayGroupGraphicsView::gestureEvent( QGestureEvent* evt )
{
    QGesture* gesture = 0;

    if( ( gesture = evt->gesture( Qt::SwipeGesture )))
    {
        evt->accept( Qt::SwipeGesture );
        swipe( static_cast< QSwipeGesture* >( gesture ));
    }
    else if( ( gesture = evt->gesture( PanGestureRecognizer::type( ))))
    {
        evt->accept( PanGestureRecognizer::type( ));
        pan( static_cast< PanGesture* >( gesture ));
    }
    else if( ( gesture = evt->gesture( PinchGestureRecognizer::type( ))))
    {
        evt->accept( PinchGestureRecognizer::type( ));
        pinch( static_cast< PinchGesture* >( gesture ));
    }
    else if( ( gesture = evt->gesture( Qt::TapGesture )))
    {
        evt->accept( Qt::TapGesture );
        tap( static_cast< QTapGesture* >( gesture ));
    }
    else if( ( gesture = evt->gesture( Qt::TapAndHoldGesture )))
    {
        evt->accept( Qt::TapAndHoldGesture );
        tapAndHold( static_cast< QTapAndHoldGesture* >( gesture ));
    }
}

void Camera::mouseInput( int x, int y, int Button, int State)
{
    if(State == GLUT_DOWN)
    {
        if(m_LastMouseX==-1) m_LastMouseX = x;
        if(m_LastMouseY==-1) m_LastMouseY = y;
        
        if( Button == GLUT_LEFT_BUTTON )
        {
            rotate((float)x, (float)y );
        }
        else if( Button == GLUT_RIGHT_BUTTON)
        {
            pan( (float)(m_LastMouseX-x)*0.01f, (float)(m_LastMouseY-y)*0.01f );
        }
        else if( Button == GLUT_MIDDLE_BUTTON)
        {
            zoom( (float)(m_LastMouseY-y)*0.01f );
            
        }

    }
    else
    {
        m_Position += m_Panning + m_Zoom + m_Rotation;
        m_Target += m_Panning;
        m_Panning = Vector(0,0,0);
        m_Zoom = Vector(0,0,0);
        m_Rotation = Vector(0,0,0);
        m_LastMouseX = -1;
        m_LastMouseY = -1;

    }
}

void Navigation::panningProcess(const QPoint & mouse)
{
    assert(PanInteraction == m_mode);

    // The first click of the interaction yields a object space position m_i0.
    // this point is our constraint for panning, that means for every mouse 
    // position there has to be an appropriate positioning for the scene, so
    // that the point under the mouse remains m_i0.
    // With this point and the up normal we build a plane, that defines the 
    // panning space. For panning, a ray is created, pointing from the screen
    // pixel into the view frustum. This ray then is converted to object space
    // and used to intersect with the plane at p. 
    // The delta of m_i0 and p is the translation required for panning.

    // constrain mouse interaction to viewport (if disabled, could lead to mishaps)
    const QPoint clamped(
        clamp(0, m_camera.viewport().width(), mouse.x())
    ,   clamp(0, m_camera.viewport().height(), mouse.y()));

    bool intersects;
    m_i1 = mouseRayPlaneIntersection(intersects, clamped, m_i0, m_viewProjectionInverted);

    if (intersects)
        pan(m_i0 - m_i1);
}

void GLWidget::mouseMoveEvent(QMouseEvent *event)
{
    int dx = event->x() - lastPos.x();
    int dy = event->y() - lastPos.y();

    if (event->buttons() & Qt::LeftButton) {
        // Es canvien els angles de visio de la camera segons el desplacament
        // Si hi ha un desplacament en X del viewport, es canviara l angle Y
        // Si hi ha un desplacament en Y del viewport, es canviara l angle X
        setYRotation( 8 * dx);
        setXRotation( 8 * dy);

    } else if (event->buttons() & Qt::RightButton) {

        // panning
        pan(dx, dy);

    } else if (event->buttons() & Qt::MidButton) {

        // zoom
        if (lastPos.y() > event->y())
            zoom(-0.05, dy);
        else
            zoom(0.05, dy);
    }

    lastPos = event->pos();
}

void WorldInHandNavigation::panProcess(const glm::ivec2 & mouse)
{
    if (PanInteraction != m_mode || !m_refPositionValid)
        return;

    // The first click of the interaction yields an object space position m_referencePosition.
    // this point is our constraint for panning, that means for every mouse 
    // position there has to be an appropriate positioning for the scene, so
    // that the point under the mouse remains m_referencePosition.
    // With this point and the up normal we build a plane, that defines the 
    // panning space. For panning, a ray is created, pointing from the screen
    // pixel into the view frustum. This ray then is converted to object space
    // and used to intersect with the plane at p. 
    // The delta of m_referencePosition and p is the translation required for panning.

    // constrain mouse interaction to viewport (if disabled, could lead to mishaps)
    const glm::ivec2 clamped(
        glm::clamp(mouse.x, 0, m_viewportCapability.width()),
        glm::clamp(mouse.y, 0, m_viewportCapability.height()));

    bool intersects = false;
    m_modifiedPosition = mouseRayPlaneIntersection(intersects, clamped, m_referencePosition, glm::vec3(0.f, 1.f, 0.f));

    if (intersects)
        pan(m_referencePosition - m_modifiedPosition);
}