1 use nihav_core::frame::*;
2 use nihav_core::codecs::*;
3 use nihav_core::io::byteio::*;
5 #[derive(Clone,Copy,Debug,PartialEq)]
20 struct QVideoDecoder {
32 f8_cache: [[u8; 16]; 240],
35 macro_rules! copy_tile {
36 ($self: expr, $doff: expr, $soff: expr) => {
39 for _y in 0..$self.tile_h {
40 for x in 0..$self.tile_w {
41 $self.frame[doff + x] = $self.frame[soff + x];
52 info: NACodecInfoRef::default(),
63 f8_cache: [[0; 16]; 240],
67 fn decode_mode7_tile(dst: &mut [u8], stride: usize, br: &mut ByteReader) -> DecoderResult<()> {
68 let op = br.peek_byte()?;
70 for dline in dst.chunks_mut(stride).take(4) {
71 br.read_buf(&mut dline[..4])?;
73 } else if op == 0xF8 || op == 0xFF {
78 let nclr = (op - 0xF6) as usize;
80 let mut pattern = br.read_u32le()?;
81 br.read_buf(&mut clr[..nclr])?;
82 for dline in dst.chunks_mut(stride).take(4) {
83 for el in dline[..4].iter_mut() {
84 *el = clr[(pattern & 3) as usize];
89 let mut pattern = br.read_u24le()?;
90 let pattern2 = br.read_u24le()?;
91 br.read_buf(&mut clr[..nclr])?;
92 for (y, dline) in dst.chunks_mut(stride).take(4).enumerate() {
93 for el in dline[..4].iter_mut() {
94 *el = clr[(pattern & 7) as usize];
106 fn decode_frame_v3(&mut self, br: &mut ByteReader, _ctype: u16) -> DecoderResult<()> {
107 let mut titer = self.tile_off.iter().enumerate();
108 let mut skip_mode = false;
109 while let Some((tile_no, &tile_off)) = titer.next() {
110 let op = br.read_byte()?;
113 let clr1 = br.read_byte()?;
115 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
116 for el in dline[..self.tile_w].iter_mut() {
121 let mut pattern = br.read_u16le()?;
122 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
123 for el in dline[..self.tile_w].iter_mut() {
124 *el = if (pattern & 0x8000) == 0 { clr0 } else { clr1 };
135 let run = br.read_byte()? as usize;
138 validate!(tile_no > 0);
139 let mut tile_off = tile_off;
142 copy_tile!(self, tile_off, self.tile_off[tile_no - 1]);
145 let (_tno, &toff) = titer.next().unwrap();
151 let off = br.read_u16le()? as usize;
152 validate!(tile_no + off < self.tile_off.len());
153 copy_tile!(self, tile_off, self.tile_off[tile_no + off]);
156 let off = br.read_u16le()? as usize;
157 validate!(off <= tile_no);
158 copy_tile!(self, tile_off, self.tile_off[tile_no - off]);
161 const MV_PART: [i8; 16] = [ 0, 4, 8, 12, 16, 20, 24, 28, -32, -4, -8, -12, -16, -20, -24, -28 ];
163 let idx = br.read_byte()? as usize;
164 let x = MV_PART[idx & 0xF] as isize;
165 let y = MV_PART[idx >> 4] as isize;
166 let src_off = (tile_off as isize) + x + y * (self.w as isize);
167 validate!(src_off >= 0);
168 validate!((src_off as usize) + self.tile_w + (self.tile_h - 1) * self.w <= self.w * self.h);
170 copy_tile!(self, tile_off, src_off as usize);
173 let off = (br.read_byte()? as usize) + 1;
174 validate!(tile_no + off < self.tile_off.len());
175 copy_tile!(self, tile_off, self.tile_off[tile_no + off]);
178 let off = (br.read_byte()? as usize) + 1;
179 validate!(off <= tile_no);
180 copy_tile!(self, tile_off, self.tile_off[tile_no - off]);
185 skip_mode = op == 0xFF;
191 fn decode_frame_5(&mut self, br: &mut ByteReader, _ctype: u16) -> DecoderResult<()> {
192 let mut titer = self.tile_off.iter().enumerate();
193 let mut last_mode = TileMode::Start;
195 while let Some((tile_no, &tile_off)) = titer.next() {
196 let op = br.read_byte()?;
199 let clr1 = br.read_byte()?;
201 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
202 for el in dline[..self.tile_w].iter_mut() {
206 last_mode = TileMode::Fill;
208 let pat = br.read_byte()?;
209 let mut pattern = if pat < 128 {
210 last_mode = TileMode::ShortPattern(clr0, clr1);
211 self.patterns[pat as usize]
213 last_mode = TileMode::LongPattern(clr0, clr1);
214 u16::from(pat) | (u16::from(br.read_byte()?) << 8)
216 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
217 for el in dline[..self.tile_w].iter_mut() {
218 *el = if (pattern & 0x8000) == 0 { clr0 } else { clr1 };
229 let run = br.read_byte()? as usize;
232 validate!(tile_no > 0);
233 validate!(last_mode != TileMode::Start);
234 let mut tile_no = tile_no;
235 let mut tile_off = tile_off;
237 let copy_off = match last_mode {
238 TileMode::Forward(off) => {
239 tile_no + (off as usize)
241 TileMode::Backward(off) => {
242 validate!(tile_no >= (off as usize));
243 tile_no - (off as usize)
245 TileMode::Skip => self.tile_off.len(),
248 if copy_off < self.tile_off.len() {
249 copy_tile!(self, tile_off, self.tile_off[copy_off]);
252 let (tno, &toff) = titer.next().unwrap();
257 last_mode = TileMode::Run;
260 let rtile = br.read_u16le()? as usize;
261 validate!(rtile < self.tile_off.len());
262 copy_tile!(self, tile_off, self.tile_off[rtile]);
263 last_mode = TileMode::Reuse;
268 let run = br.read_byte()? as usize;
270 let mut tile_no = tile_no;
271 let mut tile_off = tile_off;
274 TileMode::Start => return Err(DecoderError::InvalidData),
276 let clr = br.read_byte()?;
277 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
278 for el in dline[..self.tile_w].iter_mut() {
283 TileMode::ShortPattern(clr0, clr1) => {
284 let pat = br.read_byte()?;
285 let mut pattern = if pat < 128 {
286 self.patterns[pat as usize]
288 u16::from(pat) | (u16::from(br.read_byte()?) << 8)
290 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
291 for el in dline[..self.tile_w].iter_mut() {
292 *el = if (pattern & 0x8000) == 0 { clr0 } else { clr1 };
297 TileMode::LongPattern(clr0, clr1) => {
298 let mut pattern = br.read_u16le()?;
299 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
300 for el in dline[..self.tile_w].iter_mut() {
301 *el = if (pattern & 0x8000) == 0 { clr0 } else { clr1 };
307 let rtile = br.read_u16le()? as usize;
308 validate!(rtile < self.tile_off.len());
309 copy_tile!(self, tile_off, self.tile_off[rtile]);
312 let idx = br.read_byte()? as usize;
313 let (x, y) = DEF_MVS[idx];
314 let src_off = (tile_off as isize) + (x as isize) * 4 + (y as isize) * 4 * (self.w as isize);
315 validate!(src_off >= 0);
316 validate!((src_off as usize) + self.tile_w + (self.tile_h - 1) * self.w <= self.w * self.h);
317 copy_tile!(self, tile_off, src_off as usize);
319 TileMode::Forward(_) => {
320 let off = (br.read_byte()? as usize) + 1;
321 validate!(tile_no + off < self.tile_off.len());
322 copy_tile!(self, tile_off, self.tile_off[tile_no + off]);
324 TileMode::Backward(_) => {
325 let off = (br.read_byte()? as usize) + 1;
326 validate!(off <= tile_no);
327 copy_tile!(self, tile_off, self.tile_off[tile_no - off]);
329 _ => unimplemented!(),
333 let (tno, &toff) = titer.next().unwrap();
340 validate!(self.tile_w == 4 && self.tile_h == 4);
341 let run = br.read_byte()? as usize;
344 let mut tile_off = tile_off;
346 Self::decode_mode7_tile(&mut self.frame[tile_off..], self.w, br)?;
349 let (_tno, &toff) = titer.next().unwrap();
358 last_mode = TileMode::FB;
361 let idx = br.read_byte()? as usize;
362 let (x, y) = DEF_MVS[idx];
363 let src_off = (tile_off as isize) + (x as isize) * 4 + (y as isize) * 4 * (self.w as isize);
364 validate!(src_off >= 0);
365 validate!((src_off as usize) + self.tile_w + (self.tile_h - 1) * self.w <= self.w * self.h);
367 copy_tile!(self, tile_off, src_off as usize);
368 last_mode = TileMode::MV;
371 let off = (br.read_byte()? as usize) + 1;
372 validate!(tile_no + off < self.tile_off.len());
373 copy_tile!(self, tile_off, self.tile_off[tile_no + off]);
374 last_mode = TileMode::Forward(off as u16);
377 let off = (br.read_byte()? as usize) + 1;
378 validate!(off <= tile_no);
379 copy_tile!(self, tile_off, self.tile_off[tile_no - off]);
380 last_mode = TileMode::Backward(off as u16);
383 last_mode = TileMode::Skip;
391 fn decode_frame_7(&mut self, br: &mut ByteReader, _ctype: u16) -> DecoderResult<()> {
392 let mut titer = self.tile_off.iter().enumerate();
393 let mut last_mode = TileMode::Start;
395 let mut f8_mode = false;
396 let row_size = self.w / self.tile_w;
397 let mut next_row = 0;
398 let mut f8_data = [0; 16];
401 while let Some((tile_no, &tile_off)) = titer.next() {
402 if tile_no == next_row {
404 next_row += row_size;
406 while br.peek_byte()? == 0xF8 {
411 let idx = br.read_byte()? as usize;
413 validate!(f8_pos < self.f8_cache.len());
414 br.peek_buf(&mut self.f8_cache[f8_pos])?;
418 f8_data = self.f8_cache[f8_pos];
420 f8_data = self.f8_cache[idx - 0x10];
421 self.f8_cache[f8_pos] = f8_data;
428 let op = br.read_byte()?;
430 let (clr0, clr1) = if !f8_mode {
431 if br.peek_byte()? < 0xF8 {
432 (op, br.read_byte()?)
437 (f8_data[(op & 0xF) as usize], f8_data[(op >> 4) as usize])
439 if clr0 == clr1 && (!f8_mode || ((op & 0xF) == (op >> 4))) {
440 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
441 for el in dline[..self.tile_w].iter_mut() {
445 last_mode = TileMode::Fill;
447 let pat = br.read_byte()?;
448 let mut pattern = if pat < 128 {
449 last_mode = TileMode::ShortPattern(clr0, clr1);
450 self.patterns[pat as usize]
452 last_mode = TileMode::LongPattern(clr0, clr1);
453 u16::from(pat) | (u16::from(br.read_byte()?) << 8)
455 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
456 for el in dline[..self.tile_w].iter_mut() {
457 *el = if (pattern & 0x8000) == 0 { clr0 } else { clr1 };
468 let run = br.read_byte()? as usize;
471 validate!(tile_no > 0);
472 validate!(last_mode != TileMode::Start);
473 let mut tile_no = tile_no;
474 let mut tile_off = tile_off;
476 let copy_off = match last_mode {
477 TileMode::Forward(off) => {
478 tile_no + (off as usize)
480 TileMode::Backward(off) => {
481 validate!(tile_no >= (off as usize));
482 tile_no - (off as usize)
484 TileMode::Skip => self.tile_off.len(),
487 if copy_off < self.tile_off.len() {
488 copy_tile!(self, tile_off, self.tile_off[copy_off]);
491 let (tno, &toff) = titer.next().unwrap();
496 last_mode = TileMode::Run;
499 let rtile = br.read_u16le()? as usize;
500 validate!(rtile < self.tile_off.len());
501 copy_tile!(self, tile_off, self.tile_off[rtile]);
502 last_mode = TileMode::Reuse;
507 let run = br.read_byte()? as usize;
509 let mut tile_no = tile_no;
510 let mut tile_off = tile_off;
513 TileMode::Start => return Err(DecoderError::InvalidData),
515 let clr = br.read_byte()?;
516 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
517 for el in dline[..self.tile_w].iter_mut() {
522 TileMode::ShortPattern(clr0, clr1) => {
523 let pat = br.read_byte()?;
524 let mut pattern = if pat < 128 {
525 self.patterns[pat as usize]
527 u16::from(pat) | (u16::from(br.read_byte()?) << 8)
529 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
530 for el in dline[..self.tile_w].iter_mut() {
531 *el = if (pattern & 0x8000) == 0 { clr0 } else { clr1 };
536 TileMode::LongPattern(clr0, clr1) => {
537 let mut pattern = br.read_u16le()?;
538 for dline in self.frame[tile_off..].chunks_mut(self.w).take(self.tile_h) {
539 for el in dline[..self.tile_w].iter_mut() {
540 *el = if (pattern & 0x8000) == 0 { clr0 } else { clr1 };
546 let rtile = br.read_u16le()? as usize;
547 validate!(rtile < self.tile_off.len());
548 copy_tile!(self, tile_off, self.tile_off[rtile]);
551 let idx = br.read_byte()? as usize;
552 let (x, y) = DEF_MVS[idx];
553 let src_off = (tile_off as isize) + (x as isize) * 4 + (y as isize) * 4 * (self.w as isize);
554 validate!(src_off >= 0);
555 validate!((src_off as usize) + self.tile_w + (self.tile_h - 1) * self.w <= self.w * self.h);
556 copy_tile!(self, tile_off, src_off as usize);
558 TileMode::Forward(_) => {
559 let off = (br.read_byte()? as usize) + 1;
560 validate!(tile_no + off < self.tile_off.len());
561 copy_tile!(self, tile_off, self.tile_off[tile_no + off]);
563 TileMode::Backward(_) => {
564 let off = (br.read_byte()? as usize) + 1;
565 validate!(off <= tile_no);
566 copy_tile!(self, tile_off, self.tile_off[tile_no - off]);
568 _ => unimplemented!(),
572 let (tno, &toff) = titer.next().unwrap();
579 validate!(self.tile_w == 4 && self.tile_h == 4);
580 let run = br.read_byte()? as usize;
583 let mut tile_off = tile_off;
585 Self::decode_mode7_tile(&mut self.frame[tile_off..], self.w, br)?;
588 let (_tno, &toff) = titer.next().unwrap();
597 last_mode = TileMode::FB;
600 let idx = br.read_byte()? as usize;
601 let (x, y) = DEF_MVS[idx];
602 let src_off = (tile_off as isize) + (x as isize) * 4 + (y as isize) * 4 * (self.w as isize);
603 validate!(src_off >= 0);
604 validate!((src_off as usize) + self.tile_w + (self.tile_h - 1) * self.w <= self.w * self.h);
606 copy_tile!(self, tile_off, src_off as usize);
607 last_mode = TileMode::MV;
610 let off = (br.read_byte()? as usize) + 1;
611 validate!(tile_no + off < self.tile_off.len());
612 copy_tile!(self, tile_off, self.tile_off[tile_no + off]);
613 last_mode = TileMode::Forward(off as u16);
616 let off = (br.read_byte()? as usize) + 1;
617 validate!(off <= tile_no);
618 copy_tile!(self, tile_off, self.tile_off[tile_no - off]);
619 last_mode = TileMode::Backward(off as u16);
622 last_mode = TileMode::Skip;
631 fn output_frame(&mut self, bufinfo: &mut NABufferType, w: usize, h: usize) {
632 let bufo = bufinfo.get_vbuf();
633 let mut buf = bufo.unwrap();
634 let paloff = buf.get_offset(1);
635 let stride = buf.get_stride(0);
636 let data = buf.get_data_mut().unwrap();
637 let dst = data.as_mut_slice();
639 dst[paloff..][..768].copy_from_slice(&self.pal);
640 for (dline, sline) in dst.chunks_mut(stride).zip(self.frame.chunks(w)).take(h) {
641 dline[..w].copy_from_slice(sline);
646 impl NADecoder for QVideoDecoder {
647 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
648 if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
651 if let Some(buf) = info.get_extradata() {
652 validate!(buf.len() >= 22);
653 w = read_u16le(&buf[4..])? as usize;
654 h = read_u16le(&buf[6..])? as usize;
655 self.tile_w = buf[8] as usize;
656 self.tile_h = buf[9] as usize;
657 validate!(self.tile_w > 0 && self.tile_h > 0);
658 if self.tile_w != 4 || self.tile_h != 4 {
659 return Err(DecoderError::NotImplemented);
661 self.version = buf[2];
662 if self.version != 3{
666 validate!((w % self.tile_w) == 0);
667 validate!((h % self.tile_h) == 0);
670 return Err(DecoderError::InvalidData);
672 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, PAL8_FORMAT));
673 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
677 self.mode = match self.version {
685 self.frame.resize(w * h, 0);
687 self.tile_off = Vec::with_capacity((w / self.tile_w) * (h / self.tile_h));
689 for _y in (0..h).step_by(self.tile_h) {
690 for x in (0..w).step_by(self.tile_w) {
691 self.tile_off.push(off + x);
693 off += w * self.tile_h;
697 Err(DecoderError::InvalidData)
700 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
701 let src = pkt.get_buffer();
702 validate!(!src.is_empty());
704 let mut mr = MemoryReader::new_read(&src);
705 let mut br = ByteReader::new(&mut mr);
707 while br.left() >= 6 {
708 let ctype = br.read_u16le()?;
709 let csize = br.read_u32le()? as usize;
710 validate!(csize <= (br.left() as usize));
713 validate!(csize <= 768);
714 br.read_buf(&mut self.pal[..csize])?;
715 for el in self.pal[..csize].iter_mut() {
716 *el = (*el << 2) | (*el >> 4);
719 2 | 3 | 4 | 9 | 11 => {
720 if self.version == 5 {
721 self.mode = if ctype == 9 || ctype == 11 { 7 } else { 6 };
723 if self.version == 3 {
724 self.decode_frame_v3(&mut br, ctype)?;
725 } else if self.version < 6 {
726 self.decode_frame_5(&mut br, ctype)?;
728 self.mode = if ctype == 11 { 7 } else { 6 };
729 self.decode_frame_7(&mut br, ctype)?;
733 validate!(csize <= 256 && (csize & 1) == 0);
734 for el in self.patterns[..csize/2].iter_mut() {
735 *el = br.read_u16le()?;
739 self.mode = ctype as u8;
741 _ => return Err(DecoderError::InvalidData),
745 let mut bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
747 self.output_frame(&mut bufinfo, self.w, self.h);
749 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
750 frm.set_frame_type(if pkt.is_keyframe() { FrameType::I } else { FrameType::P });
753 fn flush(&mut self) {
757 impl NAOptionHandler for QVideoDecoder {
758 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
759 fn set_options(&mut self, _options: &[NAOption]) { }
760 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
763 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
764 Box::new(QVideoDecoder::new())
769 use nihav_core::codecs::RegisteredDecoders;
770 use nihav_core::demuxers::RegisteredDemuxers;
771 use nihav_codec_support::test::dec_video::*;
772 use crate::game_register_all_decoders;
773 use crate::game_register_all_demuxers;
775 // samples from Callahan's Crosstime Saloon, Deathgate, Mission Critical and Shannara games
778 let mut dmx_reg = RegisteredDemuxers::new();
779 game_register_all_demuxers(&mut dmx_reg);
780 let mut dec_reg = RegisteredDecoders::new();
781 game_register_all_decoders(&mut dec_reg);
783 test_decoding("legend-q", "legend-q-video", "assets/Game/dgate101.q", Some(31), &dmx_reg, &dec_reg,
784 ExpectedTestResult::MD5([0x9cc0014c, 0xf6332802, 0xfabeb715, 0xdfaa11c0]));
788 let mut dmx_reg = RegisteredDemuxers::new();
789 game_register_all_demuxers(&mut dmx_reg);
790 let mut dec_reg = RegisteredDecoders::new();
791 game_register_all_decoders(&mut dec_reg);
793 test_decoding("legend-q", "legend-q-video", "assets/Game/1925.Q", None, &dmx_reg, &dec_reg,
794 ExpectedTestResult::MD5([0xe1af971a, 0xfb509816, 0x9d60f5d6, 0xbcf48a3b]));
798 let mut dmx_reg = RegisteredDemuxers::new();
799 game_register_all_demuxers(&mut dmx_reg);
800 let mut dec_reg = RegisteredDecoders::new();
801 game_register_all_decoders(&mut dec_reg);
803 test_decoding("legend-q", "legend-q-video", "assets/Game/mc703.q", Some(16), &dmx_reg, &dec_reg,
804 ExpectedTestResult::MD5([0xf65ea3ce, 0x3052b2bb, 0xb10f8f69, 0x530d60f9]));
808 let mut dmx_reg = RegisteredDemuxers::new();
809 game_register_all_demuxers(&mut dmx_reg);
810 let mut dec_reg = RegisteredDecoders::new();
811 game_register_all_decoders(&mut dec_reg);
813 test_decoding("legend-q", "legend-q-video", "assets/Game/CCS003.Q", Some(16), &dmx_reg, &dec_reg,
814 ExpectedTestResult::MD5([0x4c0f0712, 0xc6c39f5b, 0x5bb6902f, 0x9119940e]));
818 const DEF_MVS: [(i8, i8); 256] = [
819 ( 0, 8), ( 1, 8), ( 2, 8), ( 3, 8), ( 4, 8), ( 5, 8), ( 6, 8), ( 7, 8),
820 (-8, 8), (-1, 8), (-2, 8), (-3, 8), (-4, 8), (-5, 8), (-6, 8), (-7, 8),
821 ( 0, 9), ( 1, 9), ( 2, 9), ( 3, 9), ( 4, 9), ( 5, 9), ( 6, 9), ( 7, 9),
822 (-8, 9), (-1, 9), (-2, 9), (-3, 9), (-4, 9), (-5, 9), (-6, 9), (-7, 9),
823 ( 0, 2), ( 1, 2), ( 2, 2), ( 3, 2), ( 4, 2), ( 5, 2), ( 6, 2), ( 7, 2),
824 (-8, 2), (-1, 2), (-2, 2), (-3, 2), (-4, 2), (-5, 2), (-6, 2), (-7, 2),
825 ( 0, 3), ( 1, 3), ( 2, 3), ( 3, 3), ( 4, 3), ( 5, 3), ( 6, 3), ( 7, 3),
826 (-8, 3), (-1, 3), (-2, 3), (-3, 3), (-4, 3), (-5, 3), (-6, 3), (-7, 3),
827 ( 0, 4), ( 1, 4), ( 2, 4), ( 3, 4), ( 4, 4), ( 5, 4), ( 6, 4), ( 7, 4),
828 (-8, 4), (-1, 4), (-2, 4), (-3, 4), (-4, 4), (-5, 4), (-6, 4), (-7, 4),
829 ( 0, 5), ( 1, 5), ( 2, 5), ( 3, 5), ( 4, 5), ( 5, 5), ( 6, 5), ( 7, 5),
830 (-8, 5), (-1, 5), (-2, 5), (-3, 5), (-4, 5), (-5, 5), (-6, 5), (-7, 5),
831 ( 0, 6), ( 1, 6), ( 2, 6), ( 3, 6), ( 4, 6), ( 5, 6), ( 6, 6), ( 7, 6),
832 (-8, 6), (-1, 6), (-2, 6), (-3, 6), (-4, 6), (-5, 6), (-6, 6), (-7, 6),
833 ( 0, 7), ( 1, 7), ( 2, 7), ( 3, 7), ( 4, 7), ( 5, 7), ( 6, 7), ( 7, 7),
834 (-8, 7), (-1, 7), (-2, 7), (-3, 7), (-4, 7), (-5, 7), (-6, 7), (-7, 7),
835 ( 0,-8), ( 1,-8), ( 2,-8), ( 3,-8), ( 4,-8), ( 5,-8), ( 6,-8), ( 7,-8),
836 (-8,-8), (-1,-8), (-2,-8), (-3,-8), (-4,-8), (-5,-8), (-6,-8), (-7,-8),
837 ( 0,-9), ( 1,-9), ( 2,-9), ( 3,-9), ( 4,-9), ( 5,-9), ( 6,-9), ( 7,-9),
838 (-8,-9), (-1,-9), (-2,-9), (-3,-9), (-4,-9), (-5,-9), (-6,-9), (-7,-9),
839 ( 0,-2), ( 1,-2), ( 2,-2), ( 3,-2), ( 4,-2), ( 5,-2), ( 6,-2), ( 7,-2),
840 (-8,-2), (-1,-2), (-2,-2), (-3,-2), (-4,-2), (-5,-2), (-6,-2), (-7,-2),
841 ( 0,-3), ( 1,-3), ( 2,-3), ( 3,-3), ( 4,-3), ( 5,-3), ( 6,-3), ( 7,-3),
842 (-8,-3), (-1,-3), (-2,-3), (-3,-3), (-4,-3), (-5,-3), (-6,-3), (-7,-3),
843 ( 0,-4), ( 1,-4), ( 2,-4), ( 3,-4), ( 4,-4), ( 5,-4), ( 6,-4), ( 7,-4),
844 (-8,-4), (-1,-4), (-2,-4), (-3,-4), (-4,-4), (-5,-4), (-6,-4), (-7,-4),
845 ( 0,-5), ( 1,-5), ( 2,-5), ( 3,-5), ( 4,-5), ( 5,-5), ( 6,-5), ( 7,-5),
846 (-8,-5), (-1,-5), (-2,-5), (-3,-5), (-4,-5), (-5,-5), (-6,-5), (-7,-5),
847 ( 0,-6), ( 1,-6), ( 2,-6), ( 3,-6), ( 4,-6), ( 5,-6), ( 6,-6), ( 7,-6),
848 (-8,-6), (-1,-6), (-2,-6), (-3,-6), (-4,-6), (-5,-6), (-6,-6), (-7,-6),
849 ( 0,-7), ( 1,-7), ( 2,-7), ( 3,-7), ( 4,-7), ( 5,-7), ( 6,-7), ( 7,-7),
850 (-8,-7), (-1,-7), (-2,-7), (-3,-7), (-4,-7), (-5,-7), (-6,-7), (-7,-7)