fork/slippc

git clone https://git.julia.blue/fork/slippc

Patrick CrainBumper parser and analyzer versions to synchronize with slip.py81596bb

0.4.0
20.4 KiB571 linesraw
1#include "parser.h"
2
3//Debug output convenience macros
4#define DOUT1(s) if (_debug >= 1) { std::cout << s; }
5#define DOUT2(s) if (_debug >= 2) { std::cout << s; }
6#define FAIL(e) std::cerr << "ERROR: " << e << std::endl
7#define FAIL_CORRUPT(e) std::cerr << "ERROR: " << e << "; replay may be corrupt" << std::endl
8
9namespace slip {
10
11  Parser::Parser(int debug_level) {
12    _debug = debug_level;
13    _bp    = 0;
14  }
15
16  Parser::~Parser() {
17    if (_rb != nullptr) {
18      delete [] _rb;
19    }
20    _cleanup();
21  }
22
23  bool Parser::load(const char* replayfilename) {
24    DOUT1("Loading " << replayfilename << std::endl);
25    std::ifstream myfile;
26    myfile.open(replayfilename,std::ios::binary | std::ios::in);
27    if (myfile.fail()) {
28      FAIL("File " << replayfilename << " could not be opened or does not exist");
29      return false;
30    }
31
32    myfile.seekg(0, myfile.end);
33    _file_size = myfile.tellg();
34    if (_file_size < MIN_REPLAY_LENGTH) {
35      FAIL("File " << replayfilename << " is too short to be a valid Slippi replay");
36      return false;
37    }
38    DOUT1("  File Size: " << +_file_size << std::endl);
39    myfile.seekg(0, myfile.beg);
40
41    _rb = new char[_file_size];
42    myfile.read(_rb,_file_size);
43    myfile.close();
44    return this->_parse();
45  }
46
47  bool Parser::_parse() {
48    if (not this->_parseHeader()) {
49      std::cerr << "Failed to parse header" << std::endl;
50      return false;
51    }
52    if (not this->_parseEventDescriptions()) {
53      std::cerr << "Failed to parse event descriptions" << std::endl;
54      return false;
55    }
56    if (not this->_parseEvents()) {
57      std::cerr << "Failed to parse events proper" << std::endl;
58      return false;
59    }
60    if (not this->_parseMetadata()) {
61      std::cerr << "Warning: failed to parse metadata" << std::endl;
62      //Non-fatal if we can't parse metadata, so don't need to return false
63    }
64    DOUT1("Successfully parsed replay!" << std::endl);
65    return true;
66  }
67
68  bool Parser::_parseHeader() {
69    DOUT1("Parsing header" << std::endl);
70    _bp = 0; //Start reading from byte 0
71
72    //First 15 bytes contain header information
73    if (same8(&_rb[_bp],SLP_HEADER)) {
74      DOUT1("  Slippi Header Matched" << std::endl);
75    } else {
76      FAIL_CORRUPT("Header did not match expected Slippi file header");
77      return false;
78    }
79    _length_raw_start = readBE4U(&_rb[_bp+11]);
80    if(_length_raw_start == 0) {  //TODO: this is /technically/ recoverable
81      FAIL_CORRUPT("0-byte raw data detected");
82      return false;
83    }
84    DOUT1("  Raw portion = " << _length_raw_start << " bytes" << std::endl);
85    if (_length_raw_start > _file_size) {
86      FAIL_CORRUPT("Raw data size exceeds file size of " << _file_size << " bytes");
87      return false;
88    }
89    _length_raw = _length_raw_start;
90    _bp += 15;
91    return true;
92  }
93
94  bool Parser::_parseEventDescriptions() {
95    DOUT1("Parsing event descriptions" << std::endl);
96
97    //Next 2 bytes should be 0x35
98    if (_rb[_bp] != Event::EV_PAYLOADS) {
99      FAIL_CORRUPT("Expected Event 0x" << std::hex
100        << Event::EV_PAYLOADS << std::dec << " (Event Payloads)");
101      return false;
102    }
103    uint8_t ev_bytes = _rb[_bp+1]-1; //Subtract 1 because the last byte we read counted as part of the payload
104    _payload_sizes[Event::EV_PAYLOADS] = int32_t(ev_bytes+1);
105    DOUT1("  Event description length = " << int32_t(ev_bytes+1) << " bytes" << std::endl);
106    _bp += 2;
107
108    //Next ev_bytes bytes describe events
109    for(unsigned i = 0; i < ev_bytes; i+=3) {
110      unsigned ev_code = uint8_t(_rb[_bp+i]);
111      if (_payload_sizes[ev_code] > 0) {
112        if (ev_code >= Event::EV_PAYLOADS && ev_code <= Event::GAME_END) {
113          FAIL_CORRUPT("Event " << Event::name[ev_code-Event::EV_PAYLOADS] << " payload size set multiple times");
114        } else {
115          FAIL_CORRUPT("Event " << hex(ev_code) << std::dec << " payload size set multiple times");
116        }
117        return false;
118      }
119      _payload_sizes[ev_code] = readBE2U(&_rb[_bp+i+1]);
120      DOUT1("  Payload size for event "
121        << hex(ev_code) << std::dec << ": " << _payload_sizes[ev_code]
122        << " bytes" << std::endl);
123    }
124
125    //Sanity checks to verify we at least have Payload Sizes, Game Start, Pre Frame, Post Frame, and Game End Events
126    for(unsigned i = Event::EV_PAYLOADS; i <= Event::GAME_END; ++i) {
127      if (_payload_sizes[i] == 0) {
128        FAIL_CORRUPT("Event " << Event::name[i-Event::EV_PAYLOADS] << " payload size not set");
129        return false;
130      }
131    }
132
133    //Update the remaining length of the raw data to sift through
134    _bp += ev_bytes;
135    _length_raw -= (2+ev_bytes);
136    return true;
137  }
138
139  bool Parser::_parseEvents() {
140    DOUT1("Parsing events proper" << std::endl);
141
142    bool success = true;
143    for( ; _length_raw > 0; ) {
144      unsigned ev_code = uint8_t(_rb[_bp]);
145      unsigned shift   = _payload_sizes[ev_code]+1; //Add one byte for event code
146      if (shift > _length_raw) {
147        FAIL_CORRUPT("Event byte offset exceeds raw data length");
148        return false;
149      }
150      switch(ev_code) { //Determine the event code
151        case Event::GAME_START: success = _parseGameStart(); break;
152        case Event::PRE_FRAME:  success = _parsePreFrame();  break;
153        case Event::POST_FRAME: success = _parsePostFrame(); break;
154        case Event::GAME_END:   success = _parseGameEnd();   break;
155        default:
156          std::cerr << "  Warning: unknown event code " << hex(ev_code) << " encountered; skipping" << std::endl;
157          break;
158      }
159      if (not success) {
160        return false;
161      }
162      if (_payload_sizes[ev_code] == 0) {
163        FAIL_CORRUPT("Uninitialized event " << hex(ev_code) << " encountered");
164        return false;
165      }
166      _length_raw    -= shift;
167      _bp            += shift;
168      DOUT2("  Raw bytes remaining: " << +_length_raw << std::endl);
169    }
170
171    return true;
172  }
173
174  bool Parser::_parseGameStart() {
175    DOUT1("  Parsing game start event at byte " << +_bp << std::endl);
176
177    if (_slippi_maj > 0) {
178      FAIL_CORRUPT("Duplicate game start event");
179      return false;
180    }
181
182    //Get Slippi version
183    _slippi_maj = uint8_t(_rb[_bp+0x1]); //Major version
184    _slippi_min = uint8_t(_rb[_bp+0x2]); //Minor version
185    _slippi_rev = uint8_t(_rb[_bp+0x3]); //Build version (4th char unused)
186
187    if (_slippi_maj == 0) {
188      FAIL("Replays from Slippi 0.x.x are not supported");
189      return false;
190    }
191
192    std::stringstream ss;
193    ss << +_slippi_maj << "." << +_slippi_min << "." << +_slippi_rev;
194    _slippi_version = ss.str();
195    DOUT1("    Slippi Version: " << _slippi_version << std::endl);
196
197    //Get player info
198    for(unsigned p = 0; p < 4; ++p) {
199      unsigned i                     = 0x65 + 0x24*p;
200      unsigned m                     = 0x141 + 0x8*p;
201      unsigned k                     = 0x161 + 0x10*p;
202      std::string ps                 = std::to_string(p+1);
203
204      _replay.player[p].ext_char_id  = uint8_t(_rb[_bp+i]);
205      if (_replay.player[p].ext_char_id >= CharExt::__LAST) {
206        FAIL_CORRUPT("External character ID " << +_replay.player[p].ext_char_id << " is invalid");
207        return false;
208      }
209      _replay.player[p].player_type  = uint8_t(_rb[_bp+i+0x1]);
210      _replay.player[p].start_stocks = uint8_t(_rb[_bp+i+0x2]);
211      _replay.player[p].color        = uint8_t(_rb[_bp+i+0x3]);
212      _replay.player[p].team_id      = uint8_t(_rb[_bp+i+0x9]);
213      _replay.player[p].cpu_level    = uint8_t(_rb[_bp+i+0xF]);
214      _replay.player[p].dash_back    = readBE4U(&_rb[_bp+m]);
215      _replay.player[p].shield_drop  = readBE4U(&_rb[_bp+m+0x4]);
216
217      //Decode Melee's internal tag as a proper UTF-8 string
218      if(_slippi_maj >= 2 || _slippi_min >= 3) {
219        std::u16string tag;
220        for(unsigned n = 0; n < 16; n+=2) {
221          uint16_t b = (readBE2U(_rb+_bp+k+n));
222          if ((b>>8) == 0x82) {
223            if ( (b&0xff) < 0x59) { //Roman numerals
224              b -= 0x821f;
225            } else if ( (b&0xff) < 0x80) { //Roman letters
226              b -= 0x81ff;
227            } else { //Hiragana
228              b -= 0x525e;
229            }
230          } else if ((b>>8) == 0x83) {
231            if ( (b&0xff) < 0x80) { //Katakana, part 1
232              b -= 0x529f;
233            } else { //Katakana, part 2
234              b -= 0x52a0;
235            }
236          } else if ((b>>8) == 0x81) {  //Miscellaneous characters
237            switch(b&0xff) {
238              case(0x81): b = 0x003D; break; // =
239              case(0x5b): b = 0x30FC; break; // Hiragana Wave Dash (lol)
240              case(0x7c): b = 0x002D; break; // -
241              case(0x7b): b = 0x002B; break; // +
242              case(0x49): b = 0x0021; break; // !
243              case(0x48): b = 0x003F; break; // ?
244              case(0x97): b = 0x0040; break; // @
245              case(0x93): b = 0x0025; break; // %
246              case(0x95): b = 0x0026; break; // &
247              case(0x90): b = 0x0024; break; // $
248              case(0x44): b = 0x002E; break; // .
249              case(0x60): b = 0x301C; break; // Japanese tilde
250              case(0x42): b = 0x3002; break; // Japanese period
251              case(0x41): b = 0x3001; break; // Japanese comma
252              case(0x40): b = 0x3000; break; // Space
253              default:
254                DOUT1("    Encountered unknown character in tag: " << b << std::endl);
255                b = 0;
256                break;
257            }
258          } else {
259            DOUT1("    Encountered unknown character in tag: " << b << std::endl);
260            b = 0;
261          }
262          tag += b;
263        }
264        _replay.player[p].tag_css = to_utf8(tag);
265      }
266    }
267
268    //Write to replay data structure
269    _replay.slippi_version = std::string(_slippi_version);
270    _replay.parser_version = PARSER_VERSION;
271    _replay.game_start_raw = std::string(base64_encode(reinterpret_cast<const unsigned char *>(&_rb[_bp+0x5]),312));
272    _replay.metadata       = "";
273    _replay.sudden_death   = bool(_rb[_bp+0xB]);
274    _replay.teams          = bool(_rb[_bp+0xD]);
275    _replay.items          = int8_t(_rb[_bp+0x10]);
276    _replay.stage          = readBE2U(&_rb[_bp+0x13]);
277    bool is_stock_match    = (uint8_t(_rb[_bp+0x5]) & 0x02) > 0;
278    _replay.timer          = is_stock_match ? readBE4U(&_rb[_bp+0x15])/60 : 0;
279    if (_replay.stage >= Stage::__LAST) {
280      FAIL_CORRUPT("Stage ID " << +_replay.stage << " is invalid");
281      return false;
282    }
283    _replay.seed           = readBE4U(&_rb[_bp+0x13D]);
284
285    if(_slippi_maj >= 2 || _slippi_min >= 5) {
286      _replay.pal            = bool(_rb[_bp+0x1A1]);
287    }
288    if(_slippi_maj >= 2) {
289      _replay.frozen         = bool(_rb[_bp+0x1A2]);
290    }
291
292    _max_frames = getMaxNumFrames();
293    _replay.setFrames(_max_frames);
294    DOUT1("    Estimated " << _max_frames << " gameplay frames (" << (_replay.frame_count) << " total frames)" << std::endl);
295    return true;
296  }
297
298  bool Parser::_parsePreFrame() {
299    DOUT2("  Parsing pre frame event at byte " << +_bp << std::endl);
300    int32_t fnum = readBE4S(&_rb[_bp+0x1]);
301    int32_t f    = fnum-LOAD_FRAME;
302
303    if (fnum < LOAD_FRAME) {
304      FAIL_CORRUPT("Frame index " << fnum << " less than " << +LOAD_FRAME);
305      return false;
306    }
307    if (fnum >= _max_frames) {
308      FAIL_CORRUPT("Frame index " << fnum
309        << " greater than max frames computed from reported raw size (" << _max_frames << ")");
310      return false;
311    }
312
313    uint8_t p    = uint8_t(_rb[_bp+0x5])+4*uint8_t(_rb[_bp+0x6]); //Includes follower
314    if (p > 7 || _replay.player[p].frame == nullptr) {
315      FAIL_CORRUPT("Invalid player index " << +p);
316      return false;
317    }
318
319    _replay.last_frame                      = fnum;
320    _replay.frame_count                     = f+1; //Update the last frame we actually read
321    _replay.player[p].frame[f].frame        = fnum;
322    _replay.player[p].frame[f].player       = p%4;
323    _replay.player[p].frame[f].follower     = (p>3);
324    _replay.player[p].frame[f].alive        = 1;
325    _replay.player[p].frame[f].seed         = readBE4U(&_rb[_bp+0x7]);
326    _replay.player[p].frame[f].action_pre   = readBE2U(&_rb[_bp+0xB]);
327    _replay.player[p].frame[f].pos_x_pre    = readBE4F(&_rb[_bp+0xD]);
328    _replay.player[p].frame[f].pos_y_pre    = readBE4F(&_rb[_bp+0x11]);
329    _replay.player[p].frame[f].face_dir_pre = readBE4F(&_rb[_bp+0x15]);
330    _replay.player[p].frame[f].joy_x        = readBE4F(&_rb[_bp+0x19]);
331    _replay.player[p].frame[f].joy_y        = readBE4F(&_rb[_bp+0x1D]);
332    _replay.player[p].frame[f].c_x          = readBE4F(&_rb[_bp+0x21]);
333    _replay.player[p].frame[f].c_y          = readBE4F(&_rb[_bp+0x25]);
334    _replay.player[p].frame[f].trigger      = readBE4F(&_rb[_bp+0x29]);
335    _replay.player[p].frame[f].buttons      = readBE4U(&_rb[_bp+0x31]);
336    _replay.player[p].frame[f].phys_l       = readBE4F(&_rb[_bp+0x33]);
337    _replay.player[p].frame[f].phys_r       = readBE4F(&_rb[_bp+0x37]);
338
339    if(_slippi_maj >= 2 || _slippi_min >= 2) {
340      _replay.player[p].frame[f].ucf_x        = uint8_t(_rb[_bp+0x3B]);
341      if(_slippi_maj >= 2 || _slippi_min >= 4) {
342        _replay.player[p].frame[f].percent_pre  = readBE4F(&_rb[_bp+0x3C]);
343      }
344    }
345
346    return true;
347  }
348
349  bool Parser::_parsePostFrame() {
350    DOUT2("  Parsing post frame event at byte " << +_bp << std::endl);
351    int32_t fnum = readBE4S(&_rb[_bp+0x1]);
352    int32_t f    = fnum-LOAD_FRAME;
353
354    if (fnum < LOAD_FRAME) {
355      FAIL_CORRUPT("Frame index " << fnum << " less than " << +LOAD_FRAME);
356      return false;
357    }
358    if (fnum >= _max_frames) {
359      FAIL_CORRUPT("Frame index " << fnum << " greater than max frames computed from reported raw size ("
360        << _max_frames << ")");
361      return false;
362    }
363
364    uint8_t p    = uint8_t(_rb[_bp+0x5])+4*uint8_t(_rb[_bp+0x6]); //Includes follower
365    if (p > 7 || _replay.player[p].frame == nullptr) {
366      FAIL_CORRUPT("Invalid player index " << +p);
367      return false;
368    }
369
370    _replay.player[p].frame[f].char_id       = uint8_t(_rb[_bp+0x7]);
371    if (_replay.player[p].frame[f].char_id >= CharInt::__LAST) {
372        FAIL_CORRUPT("Internal characater ID " << +_replay.player[p].frame[f].char_id << " is invalid");
373        return false;
374      }
375    _replay.player[p].frame[f].action_post   = readBE2U(&_rb[_bp+0x8]);
376    _replay.player[p].frame[f].pos_x_post    = readBE4F(&_rb[_bp+0xA]);
377    _replay.player[p].frame[f].pos_y_post    = readBE4F(&_rb[_bp+0xE]);
378    _replay.player[p].frame[f].face_dir_post = readBE4F(&_rb[_bp+0x12]);
379    _replay.player[p].frame[f].percent_post  = readBE4F(&_rb[_bp+0x16]);
380    _replay.player[p].frame[f].shield        = readBE4F(&_rb[_bp+0x1A]);
381    _replay.player[p].frame[f].hit_with      = uint8_t(_rb[_bp+0x1E]);
382    _replay.player[p].frame[f].combo         = uint8_t(_rb[_bp+0x1F]);
383    _replay.player[p].frame[f].hurt_by       = uint8_t(_rb[_bp+0x20]);
384    _replay.player[p].frame[f].stocks        = uint8_t(_rb[_bp+0x21]);
385    _replay.player[p].frame[f].action_fc     = readBE4F(&_rb[_bp+0x22]);
386
387    if(_slippi_maj >= 2) {
388      _replay.player[p].frame[f].flags_1       = uint8_t(_rb[_bp+0x26]);
389      _replay.player[p].frame[f].flags_2       = uint8_t(_rb[_bp+0x27]);
390      _replay.player[p].frame[f].flags_3       = uint8_t(_rb[_bp+0x28]);
391      _replay.player[p].frame[f].flags_4       = uint8_t(_rb[_bp+0x29]);
392      _replay.player[p].frame[f].flags_5       = uint8_t(_rb[_bp+0x2A]);
393      _replay.player[p].frame[f].hitstun       = readBE4F(&_rb[_bp+0x2B]);
394      _replay.player[p].frame[f].airborne      = bool(_rb[_bp+0x2F]);
395      _replay.player[p].frame[f].ground_id     = readBE2U(&_rb[_bp+0x30]);
396      _replay.player[p].frame[f].jumps         = uint8_t(_rb[_bp+0x32]);
397      _replay.player[p].frame[f].l_cancel      = uint8_t(_rb[_bp+0x33]);
398    }
399
400    return true;
401  }
402
403  bool Parser::_parseGameEnd() {
404    DOUT1("  Parsing game end event at byte " << +_bp << std::endl);
405    _replay.end_type       = uint8_t(_rb[_bp+0x1]);
406
407    if(_slippi_maj >= 2) {
408      _replay.lras           = int8_t(_rb[_bp+0x2]);
409    }
410    return true;
411  }
412
413  bool Parser::_parseMetadata() {
414    DOUT1("Parsing metadata" << std::endl);
415
416    //Parse metadata from UBJSON as regular JSON
417    std::stringstream ss;
418
419    std::string indent  = " ";
420    std::string key     = "";
421    std::string val     = "";
422    std::string keypath = "";  //Flattened representation of current JSON key
423    bool        done    = false;
424    bool        fail    = false;
425    int32_t     n       = 0;
426
427    std::regex comma_killer("(,)(\\s*\\})");
428
429    uint8_t strlen = 0;
430    for(unsigned i = 0; _bp+i < _file_size;) {
431      //Get next key
432      switch(_rb[_bp+i]) {
433        case 0x55: //U -> Length upcoming
434          if (_bp+i+1 >= _file_size) {
435            fail = true; break;
436          }
437          strlen = _rb[_bp+i+1];
438          if (strlen > 0) {
439            if (_bp+i+1+strlen >= _file_size) {
440              fail = true; break;
441            }
442            key.assign(&_rb[_bp+i+2],strlen);
443            // std::cout << keypath << std::endl;
444          } else {
445            key = "";  //Not sure if empty strings are actually valid, but just in case
446          }
447          keypath += ","+key;
448          if (key.compare("metadata") != 0) {
449            ss << indent << "\"" << key << "\" : ";
450          }
451          i = i+2+strlen;
452          break;
453        case 0x7d: //} -> Object ending
454          keypath = keypath.substr(0,keypath.find_last_of(","));
455          indent = indent.substr(1);
456          if (indent.length() == 0) {
457            done = true;
458            break;
459          }
460          ss << indent << "}," << std::endl;
461          i = i+1;
462          continue;
463        default:
464          std::cerr << "Warning: don't know what's happening; expected key" << std::endl;
465          return false;
466      }
467      if (done) {
468        break;
469      } else if (fail || _bp+i >= _file_size) {
470        std::cerr << "Warning: metadata shorter than expected" << std::endl;
471        return false;
472      }
473      //Get next value
474      switch(_rb[_bp+i]) {
475        case 0x7b: //{ -> Object upcoming
476          ss << "{" << std::endl;
477          if (key.compare("metadata") != 0) {
478            indent = indent+" ";
479          }
480          i = i+1;
481          break;
482        case 0x53: //S -> string upcoming
483          if (_bp+i+2 >= _file_size) {
484            fail = true; break;
485          }
486          ss << "\"";
487          if (_rb[_bp+i+1] != 0x55) {  //If the string is not of length U
488            std::cerr << "Warning: found a long string we can't parse yet:" << std::endl;
489            std::cerr << "  " << ss.str() << std::endl;
490            return false;
491          }
492          strlen = _rb[_bp+i+2];
493          if (_bp+i+2+strlen >= _file_size) {
494            fail = true; break;
495          }
496          val.assign(&_rb[_bp+i+3],strlen);
497          ss << val << "\"," << std::endl;
498          if (key.compare("startAt") == 0) {
499            _replay.start_time = val;
500          } else if (key.compare("playedOn") == 0) {
501            _replay.played_on = val;
502          } else if (key.compare("netplay") == 0) {
503            size_t portpos = keypath.find("players,");
504            if (portpos != std::string::npos) {
505              int port = keypath.substr(portpos+8,1).c_str()[0] - '0';
506              _replay.player[port].tag = val;
507            }
508          }
509          i = i+3+strlen;
510          keypath = keypath.substr(0,keypath.find_last_of(","));
511          break;
512        case 0x6c: //l -> 32-bit signed int upcoming
513          if (_bp+i+4 >= _file_size) {
514            fail = true; break;
515          }
516          n = readBE4S(&_rb[_bp+i+1]);
517          ss << std::dec << n << "," << std::endl;
518          i = i+5;
519          keypath = keypath.substr(0,keypath.find_last_of(","));
520          break;
521        default:
522          std::cerr << "Warning: don't know what's happening; expected value" << std::endl;
523          return false;
524      }
525      if (fail) {
526        std::cerr << "Warning: metadata shorter than expected" << std::endl;
527        return false;
528      }
529      continue;
530    }
531
532    std::string metadata = ss.str();
533    metadata = metadata.substr(0,metadata.length()-2);  //Remove trailing comma
534    std::string mjson;
535    std::regex_replace(  //Get rid of extraneous commas in our otherwise valid JSON
536      std::back_inserter(mjson),
537      metadata.begin(),
538      metadata.end(),
539      comma_killer,
540      "$2"
541      );
542
543    _replay.metadata = mjson;
544
545    return true;
546  }
547
548  Analysis* Parser::analyze() {
549    Analyzer a(_debug);
550    return a.analyze(_replay);
551  }
552
553  void Parser::_cleanup() {
554    _replay.cleanup();
555  }
556
557  std::string Parser::asJson(bool delta) {
558    return _replay.replayAsJson(delta);
559  }
560
561  void Parser::save(const char* outfilename,bool delta) {
562    DOUT1("Saving JSON" << std::endl);
563    std::ofstream ofile2;
564    ofile2.open(outfilename);
565    ofile2 << asJson(delta) << std::endl;
566    ofile2.close();
567    DOUT1("Saved to " << outfilename << "!" << std::endl);
568  }
569
570
571}