#include <iostream>
#include <vector>
#include <iterator>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
struct index{ 
  index(uint32_t c, size_t s): num(c), offset(s){};
 void operator()(){ std::cout<<"Num="<<num<<"  Offset="<<offset<<std::endl; };
 uint32_t num;
 size_t offset;
};

template <typename P>
struct parse{

parse(const char* f):file(f){ status=step(); };
const char* file;
P vec;
uint8_t status;

void operator()(){ 
 if(status){ std::cout<<"No \n"; return; }; 
 auto it=vec.begin();
 while(it!=vec.end()){ (*it++)(); };
 };

template <typename T>
int check(T ch, uint8_t state){
 uint8_t s=state;
 switch(ch){
  case '.' :
  case '!' :
  case '?' :
  case ',' :
  case ':' :
  case '\r':
  case '\n':
  case ';' : break;
  case ' ' : if(!s) s=1; break;
  default  : s=~s&1; break;
  };
 return s;
 };

int step(){
 struct stat st;
 size_t count=0, sz=0;
 uint32_t nm=0;
  if(stat(file, &st)==-1) return 1;
  sz=st.st_size;
 int fd=open(file, O_RDONLY);
 if(!fd) return 1;
 void* buf=mmap(NULL, sz, PROT_READ, MAP_PRIVATE,fd,0);
 if(buf==MAP_FAILED){ close(fd); return 1; };
 while(1){ 
 while(check(*(reinterpret_cast<char*>(buf)+count), 1)){ ++count; if(count==sz) return 0; };
  vec.push_back(index(++nm, count));
  while(check(*(reinterpret_cast<char*>(buf)+count), 0)){ ++count; if(count==sz) return 0; };
 };
munmap((void*)buf, sz);
close(fd);
return 0;
 };
};

int main(int c, char** s){
 
 parse<std::vector<index> > r(s[1]);
  r();
 };
  

 while(check(*(reinterpret_cast<char*>(buf)+count), 1)){ ++count; if(count==sz) return 0; };
  vec.push_back(index(++nm, count));
  while(check(*(reinterpret_cast<char*>(buf)+count), 0)){ ++count; if(count==sz) return 0; };
 };
munmap((void*)buf, sz);
close(fd);
return 0;
 };

uint8_t run=1;
 while(run){ 
 while(check(*(reinterpret_cast<char*>(buf)+count), 1)){ ++count; 
                                                        if(count==sz){ run=0; break; };
                                                          };
 if (!run) continue;
 vec.push_back(index(++nm, count));

  while(check(*(reinterpret_cast<char*>(buf)+count), 0)){  ++count; 
                                                        if(count==sz){ run=0; break; };
                                                          };
};

munmap((void*)buf, sz); close(fd);
return 0;
 };

#include <iostream>
#include <vector>
#include <iterator>
#include <fstream>

struct index{ 
  index(uint32_t c, size_t s): num(c), offset(s){};
 void operator()(){ std::cout<<"Num="<<num<<"  Offset="<<offset<<std::endl; };
 uint32_t num;
 size_t offset;
};

template <typename P>
class _GetIndex{
public:

_GetIndex(const char* f):file(f){ status=step(); };
_GetIndex(_GetIndex&& p): vec(std::move(p.vec)){ file=p.file; status=p.status; };
_GetIndex(const _GetIndex& p)=delete;
_GetIndex& operator()(const _GetIndex& p)=delete;
void operator()(){ 
 if(status){ std::cout<<"No \n"; return; }; 
 auto it=vec.begin();
 while(it!=vec.end()){ (*it++)(); };
 };

private:
const char* file;
P vec;
uint8_t status;

template <typename T>
int check(T ch, uint8_t state){
 uint8_t s=state;
 switch(ch){
  case '.' :
  case '!' :
  case '?' :
  case ',' :
  case ':' :
  case '\r':
  case '\n':
  case ';' : break;
  case ' ' : if(!s) s=1; break;
  default  : s=~s&1; break;
  };
 return s;
 };

int step(){
 char* buf;
 size_t sz=0, nm=0, count=0;
 uint8_t run=1;
 std::fstream fs(file);
  if(!fs.good()) return 1;
   fs.seekg (0, fs.end);
    sz = fs.tellg();
    fs.seekg (0, fs.beg);
 try{
  buf=new char[sz]; }catch(std::bad_alloc& c){  return 1; };
  fs.read(buf, sz);
   fs.close();
 while(run){ 
 while(check(*(buf+count), 1)){
          ++count;  if(count==sz){ run=0; break; };
           };
 if (!run) continue;
 vec.push_back(index(++nm, count));

  while(check(*(buf+count), 0)){ 
                       ++count;   if(count==sz){ run=0; break; };
            };
};

delete [] buf;
return 0;
 };
};
  
 typedef _GetIndex<std::vector<index> > GetIndex;

int main(int c, char** s){
 
 GetIndex g(s[1]);
  g();
 };