void copyFiles(char* srcFolder, char* destFolder)
{
    char* tmpPath = concatenate(bdoRootFolder,"tmp\\");
    moveFiles(srcFolder,tmpPath);
    systemCopy("*",tmpPath,destFolder);
    moveFiles(tmpPath,srcFolder);
    char rdCommand[256];
    sprintf(rdCommand, "rd /s /q \"%s\"", tmpPath);
    system(rdCommand);
}

pio_status_t
pio_open(struct pio_file_t *plink_file, const char *plink_file_prefix)
{
    int error = 0;
    int num_samples = 0;
    int num_loci = 0;
    
    char *fam_path = concatenate( plink_file_prefix, ".fam" );
    char *bim_path = concatenate( plink_file_prefix, ".bim" );
    char *bed_path = concatenate( plink_file_prefix, ".bed" );

    pio_status_t status = pio_open_ex( plink_file, fam_path, bim_path, bed_path );

    free( fam_path );
    free( bim_path );
    free( bed_path );

    return status;
}

PassRefPtr<SVGTransform> SVGTransformList::consolidate()
{
    AffineTransform matrix;
    if (!concatenate(matrix))
        return SVGTransform::create();

    RefPtr<SVGTransform> transform = SVGTransform::create(matrix);
    clear();
    return appendItem(transform);
}

VectorRecord VectorRecord::concatenate(
							const VectorRecord& inLHS,
							const VectorRecord& inRHS,
							MemoryPool* inPool,
							VectorDataManager* inVDM,
							hash_type inVectorHash
							)
	{
	if (!inLHS)
		return inRHS;
	if (!inRHS)
		return inLHS;

	if (!inLHS.isCanonicallySliced())
		return concatenate(
			inLHS.canonicallySliced(inPool, inVDM, inVectorHash + hash_type(0, 1, 0)),
			inRHS,
			inPool,
			inVDM,
			inVectorHash
			);

	if (!inRHS.isCanonicallySliced())
		return concatenate(
			inLHS,
			inRHS.canonicallySliced(inPool, inVDM, inVectorHash + hash_type(0, 2, 0)),
			inPool,
			inVDM,
			inVectorHash
			);

	return VectorRecord(
		VectorHandle::concatenate(
			inLHS.mDataPtr,
			inLHS.mSize,
			inRHS.mDataPtr,
			inRHS.mSize,
			inPool,
			inVDM,
			inVectorHash
			)
		);
	}

static void smtp_chat_append(SMTP_SESSION *session, const char *direction,
			             const char *data)
{
    char   *line;

    if (session->history == 0)
	session->history = argv_alloc(10);
    line = concatenate(direction, data, (char *) 0);
    argv_add(session->history, line, (char *) 0);
    myfree(line);
}

SVGTransform SVGTransformList::consolidate()
{
    AffineTransform matrix;
    if (!concatenate(matrix))
        return SVGTransform();

    SVGTransform transform(matrix);
    clear();
    append(transform);
    return transform;
}

static void pcf_normalize_daemon_args(ARGV *argv)
{
    int     field;
    char   *arg;
    char   *cp;
    char   *junk;
    int     extract_field;

    /*
     * Normalize options to simplify later processing.
     */
    for (field = PCF_MASTER_MIN_FIELDS; argv->argv[field] != 0; field++) {
	arg = argv->argv[field];
	if (arg[0] != '-' || strcmp(arg, "--") == 0)
	    break;
	for (cp = arg + 1; *cp; cp++) {
	    if (strchr(pcf_daemon_options_expecting_value, *cp) != 0
		&& cp > arg + 1) {
		/* Split "-stuffozz" into "-stuff" and "-ozz". */
		junk = concatenate("-", cp, (char *) 0);
		argv_insert_one(argv, field + 1, junk);
		myfree(junk);
		*cp = 0;			/* XXX argv_replace_one() */
		break;
	    }
	}
	if (strchr(pcf_daemon_options_expecting_value, arg[1]) == 0)
	    /* Option requires no value. */
	    continue;
	if (arg[2] != 0) {
	    /* Split "-oname=value" into "-o" "name=value". */
	    argv_insert_one(argv, field + 1, arg + 2);
	    arg[2] = 0;				/* XXX argv_replace_one() */
	    field += 1;
	    extract_field = (argv->argv[field][0] == CHARS_BRACE[0]);
	} else if (argv->argv[field + 1] != 0) {
	    /* Already in "-o" "name=value" form. */
	    field += 1;
	    extract_field = (argv->argv[field][0] == CHARS_BRACE[0]);
	} else
	    extract_field = 0;
	/* Extract text inside {}, optionally convert to name=value. */
	if (extract_field) {
	    pcf_extract_field(argv, field, CHARS_BRACE);
	    if (argv->argv[field - 1][1] == 'o')
		pcf_normalize_nameval(argv, field);
	}
    }
    /* Normalize non-option arguments. */
    for ( /* void */ ; argv->argv[field] != 0; field++)
	/* Extract text inside {}. */
	if (argv->argv[field][0] == CHARS_BRACE[0])
	    pcf_extract_field(argv, field, CHARS_BRACE);
}

	void MsDrbg::reseed(biglong& intenal_state, const size_t byte_len, const string& additional_input_string)
	{
		unsigned char* entropy_input = get_entropy(byte_len);
		unsigned char* internal_bytes = nullptr;
		size_t internal_size = intenal_state.get_raw_bytes(internal_bytes);
		unsigned char* internal_entropy_bytes = concatenate(internal_bytes,
		                                                    internal_size, entropy_input, byte_len);
		size_t internal_entropy_size = internal_size + byte_len;
		delete[] entropy_input;
		delete[] internal_bytes;

		unsigned char* internal_entropy_additional_bytes = concatenate(internal_entropy_bytes, internal_entropy_size,
		                                                               additional_input_string.c_str(),
		                                                               additional_input_string.length());
		size_t internal_entropy_additional_size = internal_entropy_size + additional_input_string.length();
		delete[] internal_entropy_bytes;

		intenal_state = hash_df_hex(internal_entropy_additional_bytes, internal_entropy_additional_size, byte_len);
		delete[] internal_entropy_additional_bytes;
	}

 void concatenate(string &s, unordered_set<string> &dict,
                  vector<vector<int> > &match, int cur_index, string cur_s) {
   for (int i = 0; i < match[cur_index].size(); i++) {
     int start = match[cur_index][i];
     if (start == 0) {
       r.push_back(s.substr(0, cur_index + 1) + cur_s);
     } else {
       concatenate(s, dict, match, start - 1,
                   " " + s.substr(start, cur_index - start + 1) + cur_s);
     }
   }
 }

static DICT *dict_cdbq_open(const char *path, int dict_flags)
{
    DICT_CDBQ *dict_cdbq;
    struct stat st;
    char   *cdb_path;
    int     fd;

    cdb_path = concatenate(path, CDB_SUFFIX, (char *) 0);

    if ((fd = open(cdb_path, O_RDONLY)) < 0)
	return (dict_surrogate(DICT_TYPE_CDB, path, O_RDONLY, dict_flags,
			       "open database %s: %m", cdb_path));

    dict_cdbq = (DICT_CDBQ *) dict_alloc(DICT_TYPE_CDB,
					 cdb_path, sizeof(*dict_cdbq));
#if defined(TINYCDB_VERSION)
    if (cdb_init(&(dict_cdbq->cdb), fd) != 0)
	msg_fatal("dict_cdbq_open: unable to init %s: %m", cdb_path);
#else
    cdb_init(&(dict_cdbq->cdb), fd);
#endif
    dict_cdbq->dict.lookup = dict_cdbq_lookup;
    dict_cdbq->dict.close = dict_cdbq_close;
    dict_cdbq->dict.stat_fd = fd;
    if (fstat(fd, &st) < 0)
	msg_fatal("dict_dbq_open: fstat: %m");
    dict_cdbq->dict.mtime = st.st_mtime;
    dict_cdbq->dict.owner.uid = st.st_uid;
    dict_cdbq->dict.owner.status = (st.st_uid != 0);
    close_on_exec(fd, CLOSE_ON_EXEC);

    /*
     * Warn if the source file is newer than the indexed file, except when
     * the source file changed only seconds ago.
     */
    if (stat(path, &st) == 0
	&& st.st_mtime > dict_cdbq->dict.mtime
	&& st.st_mtime < time((time_t *) 0) - 100)
	msg_warn("database %s is older than source file %s", cdb_path, path);

    /*
     * If undecided about appending a null byte to key and value, choose to
     * try both in query mode.
     */
    if ((dict_flags & (DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL)) == 0)
	dict_flags |= DICT_FLAG_TRY0NULL | DICT_FLAG_TRY1NULL;
    dict_cdbq->dict.flags = dict_flags | DICT_FLAG_FIXED;
    if (dict_flags & DICT_FLAG_FOLD_FIX)
	dict_cdbq->dict.fold_buf = vstring_alloc(10);

    myfree(cdb_path);
    return (&dict_cdbq->dict);
}

SMTP_SESSION *smtp_session_alloc(VSTREAM *stream, SMTP_ITERATOR *iter,
				         time_t start, int flags)
{
    SMTP_SESSION *session;
    const char *host = STR(iter->host);
    const char *addr = STR(iter->addr);
    unsigned port = iter->port;

    session = (SMTP_SESSION *) mymalloc(sizeof(*session));
    session->stream = stream;
    session->iterator = iter;
    session->namaddr = concatenate(host, "[", addr, "]", (char *) 0);
    session->helo = 0;
    session->port = port;
    session->features = 0;

    session->size_limit = 0;
    session->error_mask = 0;
    session->buffer = vstring_alloc(100);
    session->scratch = vstring_alloc(100);
    session->scratch2 = vstring_alloc(100);
    smtp_chat_init(session);
    session->mime_state = 0;

    if (session->port) {
	vstring_sprintf(session->buffer, "%s:%d",
			session->namaddr, ntohs(session->port));
	session->namaddrport = mystrdup(STR(session->buffer));
    } else
	session->namaddrport = mystrdup(session->namaddr);

    session->send_proto_helo = 0;

    if (flags & SMTP_MISC_FLAG_CONN_STORE)
	CACHE_THIS_SESSION_UNTIL(start + var_smtp_reuse_time);
    else
	DONT_CACHE_THIS_SESSION;
    session->reuse_count = 0;
    USE_NEWBORN_SESSION;			/* He's not dead Jim! */

#ifdef USE_SASL_AUTH
    smtp_sasl_connect(session);
#endif

#ifdef USE_TLS
    session->tls_context = 0;
    session->tls_retry_plain = 0;
    session->tls_nexthop = 0;
#endif
    session->state = 0;
    debug_peer_check(host, addr);
    return (session);
}

pio_status_t
pio_transpose(const char *plink_file_prefix, const char *transposed_file_prefix)
{
    struct pio_file_t plink_file;
    if( pio_open( &plink_file, plink_file_prefix ) != PIO_OK )
    {
        return PIO_ERROR;
    }

    char *bed_path = concatenate( plink_file_prefix, ".bed" );
    char *transposed_bed_path = concatenate( transposed_file_prefix, ".bed" );

    pio_status_t status = bed_transpose( bed_path, transposed_bed_path, pio_num_loci( &plink_file ), pio_num_samples( &plink_file ) );
    if( status == PIO_OK )
    {
        char *fam_path = concatenate( plink_file_prefix, ".fam" );
        char *transposed_fam_path = concatenate( transposed_file_prefix, ".fam" );
        file_copy( fam_path, transposed_fam_path );
        free( fam_path );
        free( transposed_fam_path );
        
        char *bim_path = concatenate( plink_file_prefix, ".bim" );
        char *transposed_bim_path = concatenate( transposed_file_prefix, ".bim" );
        file_copy( bim_path, transposed_bim_path );
        free( bim_path );
        free( transposed_bim_path );
    }

    pio_close( &plink_file );

    free( bed_path );
    free( transposed_bed_path );

    return status;
}

inline void mov_int32(int32 *value, int32 *rvalue, char pop_symbol)
{
    /* integer transfer function */
    if(pop_symbol) {
        /* perform post-evaluation operations*/
        switch(pop_symbol) {
        case '*':
            *value *= *rvalue;
            break;
        case '/':
            *value /= *rvalue;
            break;
        case '+':
            *value += *rvalue;
            break;
        case '-':
            *value -= *rvalue;
            break;
        case '%':
            *value %= *rvalue;
            break;
        case '&':
            *value &= *rvalue;
            break;
        case '|':
            *value |= *rvalue;
            break;
        case '<':
            *value<<= *rvalue;
            break;
        case '>':
            *value>>= *rvalue;
            break;
        case '~':
            *value  = ~*rvalue;
            break;
        case '!':
            *value  = factorial(*rvalue);
            break;
        case '^':
            *value  = (int32)pow(*value,*rvalue);
            break;
        case '=':
            *value  = labs(*rvalue);
            break;
        case ':':
            concatenate(value,*rvalue);
            break;
        default:
            *value = *rvalue;
        }
    } else /* there is no post-evaluation operator */

long    get_mail_conf_long2(const char *name1, const char *name2, long defval,
			            long min, long max)
{
    long    longval;
    char   *name;

    name = concatenate(name1, name2, (char *) 0);
    if (convert_mail_conf_long(name, &longval) == 0)
	set_mail_conf_long(name, longval = defval);
    check_mail_conf_long(name, longval, min, max);
    myfree(name);
    return (longval);
}

/* Check whether we have or could make a directory for history files. */
bool have_statedir(void)
{
	struct stat dirstat;
	const char *xdgdatadir;

	get_homedir();

	if (homedir != NULL) {
		statedir = concatenate(homedir, "/.nano/");

		if (stat(statedir, &dirstat) == 0 && S_ISDIR(dirstat.st_mode)) {
			poshistname = concatenate(statedir, POSITION_HISTORY);
			return TRUE;
		}
	}

	free(statedir);
	xdgdatadir = getenv("XDG_DATA_HOME");

	if (homedir == NULL && xdgdatadir == NULL)
		return FALSE;

	if (xdgdatadir != NULL)
		statedir = concatenate(xdgdatadir, "/nano/");
	else
		statedir = concatenate(homedir, "/.local/share/nano/");

	if (stat(statedir, &dirstat) == -1) {
		if (xdgdatadir == NULL) {
			char *statepath = concatenate(homedir, "/.local");
			mkdir(statepath, S_IRWXU | S_IRWXG | S_IRWXO);
			free(statepath);
			statepath = concatenate(homedir, "/.local/share");
			mkdir(statepath, S_IRWXU);
			free(statepath);
		}
		if (mkdir(statedir, S_IRWXU) == -1) {
			history_error(N_("Unable to create directory %s: %s\n"
								"It is required for saving/loading "
								"search history or cursor positions.\n"),
								statedir, strerror(errno));
			return FALSE;
		}
	} else if (!S_ISDIR(dirstat.st_mode)) {
		history_error(N_("Path %s is not a directory and needs to be.\n"
								"Nano will be unable to load or save "
								"search history or cursor positions.\n"),
								statedir);
		return FALSE;
	}

	poshistname = concatenate(statedir, POSITION_HISTORY);
	return TRUE;
}

static void smtp_chat_append(SMTPD_STATE *state, char *direction)
{
    char   *line;

    if (state->notify_mask == 0)
	return;

    if (state->history == 0)
	state->history = argv_alloc(10);
    line = concatenate(direction, STR(state->buffer), (char *) 0);
    argv_add(state->history, line, (char *) 0);
    myfree(line);
}

int     get_mail_conf_int2(const char *name1, const char *name2, int defval,
			        int min, int max)
{
    int     intval;
    char   *name;

    name = concatenate(name1, name2, (char *) 0);
    if (convert_mail_conf_int(name, &intval) == 0)
	set_mail_conf_int(name, intval = defval);
    check_mail_conf_int(name, intval, min, max);
    myfree(name);
    return (intval);
}

int main(void)
{
   ListPtr list1 = createlist('0');
   ListPtr list2 = createlist('A');

   showlist(list1);
   showlist(list2);

   concatenate(list1, list2);

   showlist(list1);

   return 0;
} /* E0F main */

void    pcf_read_parameters(void)
{
    char   *path;

    /*
     * A direct rip-off of mail_conf_read(). XXX Avoid code duplication by
     * better code decomposition.
     */
    pcf_set_config_dir();
    path = concatenate(var_config_dir, "/", MAIN_CONF_FILE, (char *) 0);
    if (dict_load_file_xt(CONFIG_DICT, path) == 0)
	msg_fatal("open %s: %m", path);
    myfree(path);
}

static void smtpd_peer_from_pass_attr(SMTPD_STATE *state)
{
    HTABLE *attr = (HTABLE *) vstream_context(state->client);
    const char *cp;

    /*
     * Extract the client endpoint information from the attribute hash.
     */
    if ((cp = htable_find(attr, MAIL_ATTR_ACT_CLIENT_ADDR)) == 0)
	msg_fatal("missing client address from proxy");
    if (strrchr(cp, ':') != 0) {
	if (valid_ipv6_hostaddr(cp, DO_GRIPE) == 0)
	    msg_fatal("bad IPv6 client address syntax from proxy: %s", cp);
	state->addr = mystrdup(cp);
	state->rfc_addr = concatenate(IPV6_COL, cp, (char *) 0);
	state->addr_family = AF_INET6;
    } else {
	if (valid_ipv4_hostaddr(cp, DO_GRIPE) == 0)
	    msg_fatal("bad IPv4 client address syntax from proxy: %s", cp);
	state->addr = mystrdup(cp);
	state->rfc_addr = mystrdup(cp);
	state->addr_family = AF_INET;
    }
    if ((cp = htable_find(attr, MAIL_ATTR_ACT_CLIENT_PORT)) == 0)
	msg_fatal("missing client port from proxy");
    if (valid_hostport(cp, DO_GRIPE) == 0)
	msg_fatal("bad TCP client port number syntax from proxy: %s", cp);
    state->port = mystrdup(cp);

    /*
     * The Dovecot authentication server needs the server IP address.
     */
    if ((cp = htable_find(attr, MAIL_ATTR_ACT_SERVER_ADDR)) == 0)
	msg_fatal("missing server address from proxy");
    if (valid_hostaddr(cp, DO_GRIPE) == 0)
	msg_fatal("bad IPv6 server address syntax from proxy: %s", cp);
    state->dest_addr = mystrdup(cp);

    if ((cp = htable_find(attr, MAIL_ATTR_ACT_SERVER_PORT)) == 0)
	msg_fatal("missing server port from proxy");
    if (valid_hostport(cp, DO_GRIPE) == 0)
	msg_fatal("bad TCP server port number syntax from proxy: %s", cp);
    state->dest_port = mystrdup(cp);

    /*
     * Convert the client address from string to binary form.
     */
    smtpd_peer_hostaddr_to_sockaddr(state);
}