void update(int x, int y, ll v) {
		int m = (s+e)/2;
		if (s == e) val->update(y, v);
		else {
			if (x > m) {
				if (r == NULL) r = new row(x, x);
				else if (!r->inrange(x)) {
					row* tmp = r;
					pi nxt = lca(s, e, r->s, r->e, x);
					r = new row(nxt.first, nxt.second);
					if (tmp->e <= (r->s + r->e)/2 ) r->l = tmp;
					else r->r = tmp;
					r->val = tmp->val->clone();
				}
				r->update(x, y, v);
			}
			else {
				if (l == NULL) l = new row(x, x);
				else if (!l->inrange(x)) {
					row* tmp = l;
					pi nxt = lca(s, e, l->s, l->e, x);
					l = new row(nxt.first, nxt.second);
					if (tmp->e <= (l->s + l->e)/2 ) l->l = tmp;
					else l->r = tmp;
					l->val = tmp->val->clone();
				}
				l->update(x, y, v);
			}
			ll rv = 0;
			if (l != NULL) rv = __gcd(l->val->query(y, y), rv);
			if (r != NULL) rv = __gcd(r->val->query(y, y), rv);
			val->update(y, rv);
		}
	}

RINGING_USING_NAMESPACE
RINGING_USING_STD

bool is_cyclic_le( const row &lh, int hunts )
{
  const int n( lh.bells() - hunts );

  // Rounds doesn't count...
  if ( lh[hunts] == hunts ) 
    return false;

  {
    for ( int i=0; i<hunts; ++i )
      if ( lh[i] != i )
	return false;
  }

  {
    for ( int i=hunts+1; i<lh.bells(); ++i )
      if ( (lh[i] - hunts) % n != (lh[i-1] + 1 - hunts) % n )
	return false;
  }

  return true;
}

void
config_reader::parse_debug_line(row<long>& dbg_line, ch_string& str_ln){
#ifdef FULL_DEBUG
	bj_ostream& os = bj_out;
	MARK_USED(os);
	
	const char* pt_in = str_ln.c_str();

	dbg_line.clear();
	
	long num_ln = 0;

	if(isalnum(*pt_in)){
		skip_whitespace(pt_in, num_ln);
		while(isdigit(*pt_in) || isspace(*pt_in)){
			if(isspace(*pt_in)){
				pt_in++;
				continue;
			}
			//os << pt_in << "$\n";
			
			long val = parse_long(pt_in, num_ln); 
			//skip_whitespace(pt_in, num_ln);
	
			dbg_line.push(val);
		}
	} else {
		skip_line(pt_in, num_ln);
	}
#endif
}

void
read_batch_instances(ch_string file_nm, row<satex_entry>& f_insts){
	bj_ostream& os = bj_out;

	std::ifstream in_stm;

	in_stm.open(file_nm.c_str(), std::ios::binary);
	if(! in_stm.good() || ! in_stm.is_open()){
		os << "NO " << file_nm << " FILE FOUND." << bj_eol;
		return;
	}

	ch_string str_ln;
	long num_ln = 0;

	f_insts.clear();

	while(! in_stm.eof()){
		std::getline(in_stm, str_ln);
		num_ln++;

		if(! str_ln.empty()){
			satex_entry& n_inst = f_insts.inc_sz();
		
			//os << "Lei:<<" << str_ln << ">>" << bj_eol;
			n_inst.parse_entry(str_ln, num_ln);
		}
	}
	in_stm.close();
}

            /*!
             * initializes with values from a database row
             */
            void record::init(const row &values) {
                if (!values.is_valid()) {
                    return;
                }

                for (auto v = values.begin(); v != values.end(); ++v) {
                    set(v.name(), v->value());
                }

                on_record_init(values);
            }

row check_solution(const matrix &A , const row &X, const row &B) {
    row diff;
    diff.resize(B.size());
    int size = B.size();
    for(int i = 0; i < size; i++) {
        double temp = 0;
        for(int j = 0; j < size; j++) {
            temp += A[i][j] * X[j];
        }
        diff[i] = temp - B[i];
    }
    return diff;
}

int table::edit_row(const row &old_row, row new_row) {
  int count = 0;
  // add column data that is not included to new_row (still enables writing empty values)
  for (int i=0;i<_Tstruct.size();i++) {
    if (!new_row.is_defined(new_row[_Tstruct[i].name])) new_row.add(_Tstruct[i], old_row[_Tstruct[i].name]);
  }
  
  if (old_row.id >= 0) {
    _fdata->seek(old_row.id*_row_size);
    _write_row(new_row._data);
    count++;
    
    // if old row's key value has changed then update the key entry (insde _keys)
    if (old_row[_key.name] != new_row[_key.name]) {
      for (int i=0;i<_keys.size();i++) {
        if (_keys[i].row_id == old_row.id) {
          _keys[i].data = new_row[_key.name]; // change key entry data to represent change
          break;
        }
      }
    }
    
  }
  else {
    query q;
    predicate p;

    for (int i=0;i<_Tstruct.size();i++) p.And( equalto(_Tstruct[i], old_row[_Tstruct[i].name]) ); // build predicate matching the row

    q.where(p);
    vector<row> results = select(q);
    for (int i=0;i<results.size();i++) {
      _fdata->seek(results[i].id * _row_size);
      _write_row(new_row._data);
      count++;
      
      // if old row's key value has changed then update the key entry (insde _keys)
      if (old_row[_key.name] != new_row[_key.name]) {
        for (int i=0;i<_keys.size();i++) {
          if (_keys[i].row_id == results[i].id) {
            _keys[i].data = new_row[_key.name]; // change key entry data to represent change
            break;
          }
        }
      }
      
    }
  }
  return count;
}

    static bool fetch(const row& res, ColOrName col_or_name, std::unique_ptr<T>& v)
    {
        T tmp;
        if (res.fetch(col_or_name, tmp))
            v.reset(new T(std::move(tmp)));

        return true;
    }

void table::delete_row(const row& del_row) {
  if (del_row.id >= 0) delete_row(del_row.id);
  else {
    predicate p;
    for (int i=0;i<_Tstruct.size();i++) if (del_row.is_defined(_Tstruct[i])) p.And( equalto(_Tstruct[i], del_row[_Tstruct[i]]) ); // build predicate matching the row
    delete_row(select(query().where(p)));
  }
}

    static bool fetch(const row& res, ColOrName col_or_name, boost::posix_time::ptime& v)
    {
        std::tm tm_struct;
        bool ret = res.fetch(col_or_name, tm_struct);
        if (ret)
            v = boost::posix_time::ptime_from_tm(tm_struct);

        return ret;
    }

    void debugEcho(const row& row_)
    {
        std::ostringstream doc;
        doc << "<row>" << std::endl;
        for(std::size_t i = 0; i != row_.size(); ++i)
        {
            const column_properties & props = row_.get_properties(i);

            doc << "   " << props.get_name();

            switch(props.get_data_type())
            {
            case dt_string:
                doc << "-string:" << row_.get<std::string>(i);
                break;
            case dt_double:
                doc << "-double:" << row_.get<double>(i);
                break;
            case dt_integer:
                doc << "-integer:" << row_.get<int>(i);
                break;
            case dt_unsigned_long:
                doc << "-ulong:" << row_.get<unsigned long>(i);
                break;
            case dt_long_long:
                doc << "-long long:" << row_.get<long long>(i);
                break;
            case dt_date:
                std::tm when = row_.get<std::tm>(i);
                doc << "-date:" << asctime(&when);
                break;
            }

            doc << std::endl;
        }
        doc << "</row>" << std::endl;

        std::cout << doc.str();
    }

bool	ck_sorted_sorsets(row<sorset*>& rr_srss, cmp_srs_func_t cmp_fn){
	std::ostream& os = std::cout;

	long the_sz = rr_srss.size();
	if(the_sz == 0){ return true; }
	sorset* lst = rr_srss[0];
	for(row_index ii = 1; ii < the_sz; ii++){
		sorset* srs = rr_srss[ii];
		if((*cmp_fn)(lst, srs) > 0){
			os << "ck_sorted_sorsets_FAILED_with" << std::endl;
			os << "srs_1=" << lst << std::endl; 	// prt_sorset
			os << "srs_2=" << srs << std::endl;   // prt_sorset
			return false;
		}
		lst = srs;
	}
	return true;
}

void
sql::write_extrinsic_comparison(relation r, const abstract_column_sequence &lhs, const row &rhs) {
    vector<thunk> lhs_thunks;
    vector<thunk> rhs_thunks;
    lhs.for_each_column([&](const column_mapper &c) {
        lhs_thunks.push_back([&](sql &cmd) {
            cmd.write_evaluation(c);
        });

        const string placeholder = next_placeholder();
        rhs_thunks.push_back([=](sql &cmd) {
            write(placeholder);
        });
        attach_cell(*rhs.find_cell(c.name()));
    });

    write_lexicographic_comparison(r, lhs_thunks, rhs_thunks);
}

void
sql::write_values(
    const abstract_mapper_base &value_mapper,
    const row &data,
    optional<column_id> excluded
) {
    write(" VALUES (");
    comma_separated_list_scope list_scope(*this);
    value_mapper.for_each_persistent_column(
        [&](const persistent_column_mapper &p) {
            if (p.id() != excluded) {
                list_scope.start_item();
                write_value(*data.find_cell(p.name()));
            }
        }
    );
    write(")");
}

row solve_progon(const matrix &A,const row &B) {
    row P, Q, ans;
    int N = B.size();
    P.resize(N);
    Q.resize(N);
    ans.resize(N);
    P[0] = - A[0][1] / A[0][0];
    Q[0] = B[0]/A[0][0];
    //Pr9moy xod
    for(int i = 1; i < N; i++) {
        P[i] = A[i][i + 1]/(-A[i][i] - A[i][i - 1]*P[i-1]);
        Q[i] = (A[i][i - 1] * Q[i - 1] - B[i]) / (-A[i][i] - A[i][i-1] * P[i - 1]);
    }

    //Obratniy xod
    ans[N - 1] = (A[N-1][N-2] * Q[N-2] - B[N-1]) / (-A[N-1][N-1] - A[N-1][N-2] * P[N-2]);
    for(int i = N - 2; i >= 0; --i) {
        ans[i] = P[i] * ans[i+1] + Q[i];
    }
    return ans;
}

bool	ck_sorted_elems(row<elem_sor*>& rr_ele, cmp_elems_func_t cmp_fn){
	std::ostream& os = std::cout;

	long the_sz = rr_ele.size();
	if(the_sz == 0){ return true; }
	elem_sor* lst = rr_ele[0];
	for(row_index ii = 1; ii < the_sz; ii++){
		elem_sor* ele = rr_ele[ii];
		if((*cmp_fn)(lst, ele) > 0){
			os << "ck_sorted_elems_FAILED_with" << std::endl;
			os << "ele_1=" << *lst << std::endl;
			os << "ele_2=" << *ele << std::endl;

			os << "ids_1=" << lst->es_ids << std::endl;
			os << "ids_2=" << ele->es_ids << std::endl;
			return false;
		}
		lst = ele;
	}
	return true;
}

row solve(const row &left,const row &mid,const row &right, int j) {
    int size = left.size();
    double pt, bt;
	row B(size);
    matrix A(size, row(size));
    for(int i = 0; i < A.size(); i++) {
        if(i - 1 >=0)
            A[i][i-1] = 1;
        A[i][i] = -2;
        if(i + 1 < A.size())
            A[i][i+1] = 1;
        if(i == 0)
            pt = 0;
        else
            pt = mid[i-1];
        if (i == A.size() - 1)
            bt = 0;
        else 
            bt = mid[i+1];
        B[i] = (-left[i] + 2 * mid[i] - right[i]) * dt /(R * C) + (pt - 2 * mid[i] + bt) + I[j][i] * dt/C;//(left[i] - 2 * mid[i] + right[i]) * (dt / (R * C) - 1) + I[j][i] * dt / C ;
    }
    row s = solve_progon(A, B);
    return s;
}

void print_matrix(const row &v) {
    for(int i = 0; i < v.size(); i++){ 
        std::cout << v[i] << std::endl;
    }
}

void single_source_dijkstra_path_basic(Graph &G,int s,row &S,tablist &P,int* sigma,float* D)
{
    /*
       Graph G:G is the graph object
       s:s is the source vertex.
       S:S will contain the nodes in a topological order.
       P:P[w] gives the predecessors of w in the DAG rooted at s.
       sigma:sigma[t] gives the number of shortest paths from s to t.
       D:D[t] gives the distance from s to t.
    */
    float vw_dist;
    onemap_d seen;
    int* find=new int[G.len()];
    for(int i=0;i<G.len();i++)
    {
        find[i]=0;
    }
    for(int i=0;i<G.len();i++)
    {
        D[i]=numeric_limits<float>::infinity();
        sigma[i]=0;
    }
    sigma[s]=1;
    seen[s]=0.0;
    /*Create a priority queue*/
    priority_queue<Elem,vector<Elem>,dist_compare> Q;
    /*Add s to the queue*/
    Elem e1(s,s,0.0);
    Q.push(e1);
    S.reserve(G.len()+1);
    while(!Q.empty())
    {
        Elem e=Q.top();
        Q.pop();
        int v=e.node;
        if(find[v]==1)
        {    
            continue;
        }
        if(v!=s)
        {
           sigma[v]+=sigma[e.pred];
        }  
        S.push_back (v);   
        D[v]=e.dist;
        find[v]=1;
        for (vector<Edge>::iterator it = G.adj_list[v].begin(); it != G.adj_list[v].end(); ++it)
        {   
            int w=it->vertex;
            vw_dist=e.dist+ it->weight;
            if ((find[w]==0)&&((seen.find(w)==seen.end())||(vw_dist<seen[w])))
            {
                seen[w]=vw_dist;
                Q.push( Elem(v,w,vw_dist));
                sigma[w]=0;
                vector<int> new_vector(1);
                new_vector[0]=v;
                P[w]=new_vector;
            }
            else if (abs(vw_dist-seen[w])<EPSILON)    
            {
                sigma[w]+=sigma[v];
                P[w].push_back(v);
            }
                                                         
        }
    }
	delete[] find;
    return;    
}

outFileTable::outFileTable(const std::string & filename,const row & header):_fileName(filename),tableAbs(header.getDelim()){//output
//create outFileTable with this constructor ; inherits fileTable
      _columnHeaders=header;
      std::ofstream tmpOutFile;
      tmpOutFile.open(filename, std::ios::out | std::ios::app);
     if(!tmpOutFile.is_open())
        {
         throw std::runtime_error("Could not open file for writing.\n");
        }
      tmpOutFile.close();
 

}