{-# LANGUAGE BangPatterns #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE UndecidableInstances #-} import Control.Monad import Control.Monad.Cont import Control.Monad.ST import Control.Monad.State import Data.Bits import Data.Bool import Data.Char import Data.Coerce import Data.Int import Data.Maybe import Data.Word import GHC.Exts import System.IO import Unsafe.Coerce import qualified Data.ByteString as BS import qualified Data.ByteString.Builder as BSB import qualified Data.ByteString.Char8 as BSC8 import qualified Data.ByteString.Unsafe as BSU import qualified GHC.Integer.GMP.Internals as GMP import qualified Data.Vector as V import qualified Data.Vector.Mutable as VM import qualified Data.Vector.Fusion.Stream.Monadic as VFSM import qualified Data.Vector.Generic as VG import qualified Data.Vector.Unboxed as VU import qualified Data.Vector.Unboxed.Mutable as VUM main :: IO () main = do query <- readLn :: IO Int xs <- V.replicateM query $ seqInput 9 putBuilder $ v2BLinesWith (bool "Miss" "Hit") $ V.map solver xs _w, _h, _d, _mx, _my, _hx, _hy, _vx, _vy :: Int _w = 0 {-# INLINE _w #-} _h = 1 {-# INLINE _h #-} _d = 2 {-# INLINE _d #-} _mx = 3 {-# INLINE _mx #-} _my = 4 {-# INLINE _my #-} _hx = 5 {-# INLINE _hx #-} _hy = 6 {-# INLINE _hy #-} _vx = 7 {-# INLINE _vx #-} _vy = 8 {-# INLINE _vy #-} solver :: VU.Vector Int -> Bool solver xs = runST $ do let tempVX = xs VU.! _vx tempVY = xs VU.! _vy w = xs VU.! _w h = xs VU.! _h (mx, hx, vx) = if tempVX < 0 then (w - xs VU.! _mx, w - xs VU.! _hx, - tempVX) else (xs VU.! _mx, xs VU.! _hx, tempVX) (my, hy, vy) = if tempVY < 0 then (h - xs VU.! _my, h - xs VU.! _hy, - tempVY) else (xs VU.! _my, xs VU.! _hy, tempVY) if vx == 0 then do if mx == hx && ((my > hy && (my - hy) <= (xs VU.! _d) * vy) || (my < hy && (2 * h - my - hy) <= (xs VU.! _d) * vy)) then return True else return False else do if vy == 0 then do if my == hy && (((mx > hx) && (mx - hx <= (xs VU.! _d) * vx)) || (mx < hx && ((2 * w - mx - hx) <= (xs VU.! _d) * vx))) then return True else return False else do let g = gcd vx vy d = (xs VU.! _d) * g vx' = vx `div` g vy' = vy `div` g ys = map fromIntegral [w, h, d, hx, hy, vx', vy'] if solver' ys (fi mx) (fi my) || solver' ys (fi (2 * w - mx)) (fi my) || solver' ys (fi mx) (fi (2 * h - my)) || solver' ys (fi (2 * w - mx)) (fi (2 * h - my)) then return True else return False solver' :: [Integer] -> Integer -> Integer -> Bool solver' (w:h:d:hx:hy:vx:vy:_) tx ty = runST $ do let a = 2 * w * vy b = -2 * h * vx c = ty * vx - tx * vy + hx * vy - hy * vx g = gcd a (-b) if c `mod` g > 0 then return False else do let a' = a `div` g b' = b `div` g c' = c `div` g (_, y) = extgcd b' a' m = c' * y `mod` a' tv = ((ty + 2 * h * m - hy) `div` vy) `mod` (2 * h * a' `div` vy) sv = if tv < 0 then tv + 2 * h * a' `div` vy else tv return $ sv <= d stream :: Monad m => Int -> Int -> VFSM.Stream m Int stream !l !r = VFSM.Stream step l where step x | x < r = return $ VFSM.Yield x (x + 1) | otherwise = return $ VFSM.Done {-# INLINE [0] step #-} {-# INLINE [1] stream #-} rep :: Monad m => Int -> (Int -> m ()) -> m () rep n = flip VFSM.mapM_ (stream 0 n) {-# INLINE rep #-} withBreak :: ((r -> ContT r IO b) -> ContT r IO r) -> IO r withBreak = flip runContT pure . callCC {-# INLINE withBreak #-} infixl 8 .<<., .>>., .>>>. infixl 6 .^. (.<<.) :: Bits b => b -> Int -> b (.<<.) = unsafeShiftL {-# INLINE (.<<.) #-} (.>>.) :: Bits b => b -> Int -> b (.>>.) = unsafeShiftR {-# INLINE (.>>.) #-} (.>>>.) :: Int -> Int -> Int (.>>>.) (I# x#) (I# i#) = I# (uncheckedIShiftRL# x# i#) {-# INLINE (.>>>.) #-} (.^.) :: Bits b => b -> b -> b (.^.) = xor {-# INLINE (.^.) #-} clz :: FiniteBits fb => fb -> Int clz = countLeadingZeros {-# INLINE clz #-} ctz :: FiniteBits fb => fb -> Int ctz = countTrailingZeros {-# INLINE ctz #-} encode32x2 :: Int -> Int -> Int encode32x2 x y = x .<<. 32 .|. y {-# INLINE encode32x2 #-} decode32x2 :: Int -> (Int, Int) decode32x2 xy = let !x = xy .>>>. 32 !y = xy .&. 0xffffffff in (x, y) {-# INLINE decode32x2 #-} ceilPow2 :: Int -> Int ceilPow2 n | n > 1 = (-1) .>>>. (clz (n - 1)) + 1 | otherwise = 1 {-# INLINE ceilPow2 #-} floorPow2 :: Int -> Int floorPow2 n | n >= 1 = 1 .<<. (63 - (clz n)) | otherwise = 0 {-# INLINE floorPow2 #-} bitReverse :: Int -> Int bitReverse = unsafeCoerce . step 32 0xffffffff00000000 0x00000000ffffffff . step 16 0xffff0000ffff0000 0x0000ffff0000ffff . step 08 0xff00ff00ff00ff00 0x00ff00ff00ff00ff . step 04 0xf0f0f0f0f0f0f0f0 0x0f0f0f0f0f0f0f0f . step 02 0xcccccccccccccccc 0x3333333333333333 . step 01 0xaaaaaaaaaaaaaaaa 0x5555555555555555 . unsafeCoerce where step :: Int -> Word64 -> Word64 -> Word64 -> Word64 step i ml mr = \ !x -> (x .&. ml) .>>. i .|. (x .&. mr) .<<. i {-# INLINE step #-} fi :: Int -> Integer fi = fromIntegral {-# INLINE fi #-} fI :: Integer -> Int fI = fromInteger {-# INLINE fI #-} fid :: Int -> Double fid = fromIntegral {-# INLINE fid #-} fif :: Int -> Float fif = fromIntegral {-# INLINE fif #-} powModInt :: Int -> Int -> Int -> Int powModInt a n mo = fI $ GMP.powModInteger (fi a) (fi n) (fi mo) recipModInt :: Int -> Int -> Int recipModInt a mo = fI $ GMP.recipModInteger (fi a) (fi mo) extgcd :: Integer -> Integer -> (Integer, Integer) extgcd a b = case GMP.gcdExtInteger a b of (# p, q #) -> (p, q) floorSqrt :: Int -> Int floorSqrt = floor . sqrt . fromIntegral floorLog2 :: Int -> Int floorLog2 x = fromIntegral $ y `unsafeShiftR` 52 - 1023 where y :: Word64 y = unsafeCoerce (fromIntegral x :: Double) type CParser a = StateT BSC8.ByteString Maybe a runCParser :: CParser a -> BSC8.ByteString -> Maybe (a, BSC8.ByteString) runCParser = runStateT {-# INLINE runCParser #-} int :: CParser Int int = coerce $ BSC8.readInt . BSC8.dropWhile isSpace {-# INLINE int #-} int1 :: CParser Int int1 = fmap (subtract 1) int {-# INLINE int1 #-} char :: CParser Char char = coerce BSC8.uncons {-# INLINE char #-} byte :: CParser Word8 byte = coerce BS.uncons {-# INLINE byte #-} skipSpaces :: CParser () skipSpaces = modify' (BSC8.dropWhile isSpace) {-# INLINE skipSpaces #-} seqInput :: Int -> IO (VU.Vector Int) seqInput n = VU.unfoldrN n (runCParser int) <$> BSC8.getLine {-# INLINE seqInput #-} parseN1 :: Int -> IO (VU.Vector Int) parseN1 n = VU.unfoldrN n (runCParser int) <$> BSC8.getContents {-# INLINE parseN1 #-} parseN2 :: Int -> IO (VU.Vector (Int, Int)) parseN2 n = VU.unfoldrN n (runCParser $ (,) <$> int <*> int) <$> BSC8.getContents {-# INLINE parseN2 #-} parseN3 :: Int -> IO (VU.Vector (Int, Int, Int)) parseN3 n = VU.unfoldrN n (runCParser $ (,,) <$> int <*> int <*> int) <$> BSC8.getContents {-# INLINE parseN3 #-} parseN4 :: Int -> IO (VU.Vector (Int, Int, Int, Int)) parseN4 n = VU.unfoldrN n (runCParser $ (,,,) <$> int <*> int <*> int <*> int) <$> BSC8.getContents {-# INLINE parseN4 #-} parseN5 :: Int -> IO (VU.Vector (Int, Int, Int, Int, Int)) parseN5 n = VU.unfoldrN n (runCParser $ (,,,,) <$> int <*> int <*> int <*> int <*> int) <$> BSC8.getContents {-# INLINE parseN5 #-} parseANBN :: Int -> IO (VU.Vector Int, VU.Vector Int) parseANBN n = VU.unzip . VU.unfoldrN n (runCParser $ (,) <$> int <*> int) <$> BSC8.getContents {-# INLINE parseANBN #-} parseANBNCN :: Int -> IO (VU.Vector Int, VU.Vector Int, VU.Vector Int) parseANBNCN n = VU.unzip3 . VU.unfoldrN n (runCParser $ (,,) <$> int <*> int <*> int) <$> BSC8.getContents {-# INLINE parseANBNCN #-} type Query3 = (Int, Int, Int) query3Parser :: CParser Query3 query3Parser = do skipSpaces t <- char case t of '0' -> (,,) 0 <$> int <*> int _ -> (,,) 1 <$> int <*> pure 0 type Query5 = (Int, Int, Int, Int, Int) query5Parser :: CParser Query5 query5Parser = do skipSpaces t <- char case t of '0' -> (,,,,) 0 <$> int <*> int <*> int <*> int _ -> (,,,,) 1 <$> int <*> int <*> pure 0 <*> pure 0 parseQ5 :: Int -> IO (VU.Vector Query5) parseQ5 n = VU.unfoldrN n (runCParser query5Parser) <$> BSC8.getContents {-# INLINE parseQ5 #-} readInt :: BSC8.ByteString -> Int readInt = fst . fromJust . BSC8.readInt {-# INLINE readInt #-} getInt :: IO Int getInt = readInt <$> BSC8.getLine {-# INLINE getInt #-} readIntList :: BSC8.ByteString -> [Int] readIntList = map readInt . BSC8.words {-# INLINE readIntList #-} getIntList :: IO [Int] getIntList = readIntList <$> BS.getLine {-# INLINE getIntList #-} readInteger :: BSC8.ByteString -> Integer readInteger = fst . fromJust . BSC8.readInteger {-# INLINE readInteger #-} getInteger :: IO Integer getInteger = readInteger <$> BSC8.getLine {-# INLINE getInteger #-} readIntegerList :: BSC8.ByteString -> [Integer] readIntegerList = map readInteger . BSC8.words {-# INLINE readIntegerList #-} getIntegerList :: IO [Integer] getIntegerList = readIntegerList <$> BS.getLine {-# INLINE getIntegerList #-} class ShowAsBuilder a where showAsBuilder :: a -> BSB.Builder default showAsBuilder :: (Show a) => a -> BSB.Builder showAsBuilder = BSB.string8 . show instance ShowAsBuilder Int where showAsBuilder = BSB.intDec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Int8 where showAsBuilder = BSB.int8Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Int16 where showAsBuilder = BSB.int16Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Int32 where showAsBuilder = BSB.int32Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Int64 where showAsBuilder = BSB.int64Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Word8 where showAsBuilder = BSB.word8Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Word16 where showAsBuilder = BSB.word16Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Word32 where showAsBuilder = BSB.word32Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Word64 where showAsBuilder = BSB.word64Dec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Integer where showAsBuilder = BSB.integerDec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Float where showAsBuilder = BSB.floatDec {-# INLINE showAsBuilder #-} instance ShowAsBuilder Double where showAsBuilder = BSB.doubleDec {-# INLINE showAsBuilder #-} instance (ShowAsBuilder a, VG.Vector v a) => ShowAsBuilder (v a) where showAsBuilder = v2BSpcSep putBuilder :: BSB.Builder -> IO () putBuilder = BSB.hPutBuilder stdout {-# INLINE putBuilder #-} printVecInLines :: (VG.Vector v a, ShowAsBuilder a) => v a -> IO () printVecInLines = putBuilder . v2BLines {-# INLINE printVecInLines #-} printVecInSpcSepLn :: (VG.Vector v a, ShowAsBuilder a) => v a -> IO () printVecInSpcSepLn = putBuilder . v2BSpcSepLn {-# INLINE printVecInSpcSepLn #-} v2BSpcSepLn :: (VG.Vector v a, ShowAsBuilder a) => v a -> BSB.Builder v2BSpcSepLn = v2BSpcSepLnWith showAsBuilder {-# INLINE v2BSpcSepLn #-} v2BSpcSep :: (VG.Vector v a, ShowAsBuilder a) => v a -> BSB.Builder v2BSpcSep = v2BSpcSepWith showAsBuilder {-# INLINE v2BSpcSep #-} v2BConcat:: (VG.Vector v a, ShowAsBuilder a) => v a -> BSB.Builder v2BConcat = v2BConcatWith showAsBuilder {-# INLINE v2BConcat #-} v2BLines:: (VG.Vector v a, ShowAsBuilder a) => v a -> BSB.Builder v2BLines = v2BLinesWith showAsBuilder {-# INLINE v2BLines #-} v2BSpcSepLnWith :: VG.Vector v a => (a -> BSB.Builder) -> v a -> BSB.Builder v2BSpcSepLnWith = v2BSpcSepPostfWith "\n" {-# INLINE v2BSpcSepLnWith #-} v2BSpcSepWith :: VG.Vector v a => (a -> BSB.Builder) -> v a -> BSB.Builder v2BSpcSepWith = v2BSpcSepPostfWith "" {-# INLINE v2BSpcSepWith #-} v2BConcatWith :: VG.Vector v a => (a -> BSB.Builder) -> v a -> BSB.Builder v2BConcatWith showFct = VG.foldr ((<>) . showFct) mempty {-# INLINE v2BConcatWith #-} v2BLinesWith :: VG.Vector v a => (a -> BSB.Builder) -> v a -> BSB.Builder v2BLinesWith showFct = VG.foldr (\a -> (showFct a <>) . (BSB.char7 '\n' <>)) mempty {-# INLINE v2BLinesWith #-} v2BSpcSepPostf :: (VG.Vector v a, ShowAsBuilder a) => BS.ByteString -> v a -> BSB.Builder v2BSpcSepPostf = (`v2BSpcSepPostfWith` showAsBuilder) {-# INLINE v2BSpcSepPostf #-} v2BSpcSepPostfWith :: VG.Vector v a => BS.ByteString -> (a -> BSB.Builder) -> v a -> BSB.Builder v2BSpcSepPostfWith = vecToBuilder "" " " {-# INLINE v2BSpcSepPostfWith #-} vecToBuilder :: VG.Vector v a => BS.ByteString -> BS.ByteString -> BS.ByteString -> (a -> BSB.Builder) -> v a -> BSB.Builder vecToBuilder !prefix !separator !postfix = vecToBuilder_ (BSB.byteString prefix) (BSB.byteString separator) (BSB.byteString postfix) {-# INLINE vecToBuilder #-} vecToBuilder_ :: VG.Vector v a => BSB.Builder -> BSB.Builder -> BSB.Builder -> (a -> BSB.Builder) -> v a -> BSB.Builder vecToBuilder_ !prefix !separator !postfix showFct vec = prefix <> VG.foldr (\a rest !prefx -> prefx <> (showFct a <> rest separator)) (const postfix) vec mempty {-# INLINE vecToBuilder_ #-}