void
init(agent* array)
{
array->val_best = INF;
init_weight(array);
init_thresh(array);
}
void
update(agent* p)
{
unsigned int i, k, n;
static float inherit_weight = 1;
float weight1;
float weight2;
weight1 = RAND(2, 0);
weight2 = RAND(2, 0);
for(i = 0; i < N_LAY-1; i++)
for(n = 0; n < neuron_num[i+1]; n++)
for(k = 0; k < neuron_num[i]; k++)
{
p->weight_velo[i][n][k] *= inherit_weight;
p->weight_velo[i][n][k] += weight1*(p->weight_best[i][n][k] - p->weight_curr[i][n][k])
+ weight2*(g_weight_best[i][n][k] - p->weight_curr[i][n][k]);
p->weight_curr[i][n][k] += p->weight_velo[i][n][k]; //update_position
if(fabs(p->weight_velo[i][n][k]) > INF || fabs(p->weight_curr[i][n][k]) > INF)
{
init_thresh(p);
init_weight(p);
}
}
for(i = 0; i < N_LAY; i++)
for(k = 0; k < neuron_num[i]; k++)
{
p->thresh_velo[i][k] *= inherit_weight;
p->thresh_velo[i][k] += weight1*(p->thresh_best[i][k] - p->thresh_curr[i][k])
+ weight2*(g_thresh_best[i][k] - p->thresh_curr[i][k]);
p->thresh_curr[i][k] = p->thresh_velo[i][k]; //update_position
if(fabs(p->thresh_velo[i][k]) > INF || fabs(p->thresh_curr[i][k]) > INF)
{
init_thresh(p);
init_weight(p);
}
}
inherit_weight *= 0.9999;
}
int main(int argc, char **argv)
{
FILE *rule_fp;
Topform c;
Term t;
int i;
Clause_eval compiled_rule;
Plist rules = NULL;
init_standard_ladr();
init_weight(NULL, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0);
i = register_attribute("label", STRING_ATTRIBUTE); /* ignore these */
i = register_attribute("answer", TERM_ATTRIBUTE); /* ignore these */
rule_fp = fopen(argv[1], "r");
if (rule_fp == NULL)
fatal_error("test_clause_eval, rule file cannot be opened for reading");
t = read_term(rule_fp, stderr); /* get first rule */
while (t != NULL) {
compiled_rule = compile_clause_eval_rule(t);
rules = plist_append(rules, compiled_rule);
fwrite_term_nl(stdout, t);
zap_term(t);
t = read_term(rule_fp, stderr);
}
fclose(rule_fp);
/* Evaluate each clause on stdin. */
c = read_clause(stdin, stderr);
while (c != NULL && !end_of_list_clause(c)) {
Plist p;
c->weight = clause_weight(c->literals);
for (p = rules; p; p = p->next) {
Clause_eval rule = p->v;
BOOL result = eval_clause_in_rule(c, rule);
printf("%d (wt=%.3f) : ", result, c->weight);
fwrite_clause(stdout, c, CL_FORM_BARE);
}
printf("\n");
zap_topform(c);
c = read_clause(stdin, stderr);
}
exit(0);
} /* main */
int main() {
bool f**k = false;
while (scanf("%d%d", &n, &m)) {
if (n == 0 && m == 0) break;
if (f**k) printf("\n");
f**k = true;
init_data();
init_weight();
find_all_posible_circumstances();
count_ratio_for_all_circumstances();
find_min_ratio_and_output();
}
return 0;
}
/*
* Create a network of the given size.
*/
void make_learner(net *learn, int input, int hidden, int output)
{
int i, j;
/* Set number of outputs */
learn->num_output = output;
/* Set number of inputs */
learn->num_inputs = input;
/* Number of hidden nodes */
learn->num_hidden = hidden;
/* Clear error counters */
learn->error = learn->num_error = 0;
/* Create input array */
learn->input_value = (double *)malloc(sizeof(double) * (input + 1));
/* Create array for previous inputs */
learn->prev_input = (double *)malloc(sizeof(double) * (input + 1));
/* Create hidden sum array */
learn->hidden_sum = (double *)malloc(sizeof(double) * hidden);
/* Create hidden result array */
learn->hidden_result = (double *)malloc(sizeof(double) * (hidden + 1));
/* Create hidden error array */
learn->hidden_error = (double *)malloc(sizeof(double) * hidden);
/* Create output result array */
learn->net_result = (double *)malloc(sizeof(double) * output);
/* Create output probability array */
learn->win_prob = (double *)malloc(sizeof(double) * output);
/* Last input and hidden result are always 1 (for bias) */
learn->input_value[input] = 1.0;
learn->hidden_result[hidden] = 1.0;
/* Create rows of hidden weights */
learn->hidden_weight = (double **)malloc(sizeof(double *) *
(input + 1));
/* Create rows of hidden weight deltas */
learn->hidden_delta = (double **)malloc(sizeof(double *) *
(input + 1));
/* Loop over hidden weight rows */
for (i = 0; i < input + 1; i++)
{
/* Create weight row */
learn->hidden_weight[i] = (double *)malloc(sizeof(double) *
hidden);
/* Create weight delta row */
learn->hidden_delta[i] = (double *)malloc(sizeof(double) *
hidden);
/* Randomize weights */
for (j = 0; j < hidden; j++)
{
/* Randomize this weight */
init_weight(&learn->hidden_weight[i][j]);
/* Clear delta */
learn->hidden_delta[i][j] = 0;
}
}
/* Create rows of output weights */
learn->output_weight = (double **)malloc(sizeof(double *) *
(hidden + 1));
/* Create rows of output weight deltas */
learn->output_delta = (double **)malloc(sizeof(double *) *
(hidden + 1));
/* Loop over output weight rows */
for (i = 0; i < hidden + 1; i++)
{
/* Create weight row */
learn->output_weight[i] = (double *)malloc(sizeof(double) *
output);
/* Create weight delta row */
learn->output_delta[i] = (double *)malloc(sizeof(double) *
output);
/* Randomize weights */
for (j = 0; j < output; j++)
{
/* Randomize this weight */
init_weight(&learn->output_weight[i][j]);
/* Clear delta */
learn->output_delta[i][j] = 0;
}
}
/* Clear hidden sums */
memset(learn->hidden_sum, 0, sizeof(double) * hidden);
/* Clear hidden errors */
memset(learn->hidden_error, 0, sizeof(double) * hidden);
/* Clear previous inputs */
memset(learn->prev_input, 0, sizeof(double) * (input + 1));
/* Create set of previous inputs */
learn->past_input = (double **)malloc(sizeof(double *) * PAST_MAX);
/* Create set of previous input players */
learn->past_input_player = (int *)malloc(sizeof(int) * PAST_MAX);
/* No past inputs available */
learn->num_past = 0;
/* No training done */
learn->num_training = 0;
/* Create array for input names */
learn->input_name = (char **)malloc(sizeof(char *) * input);
/* Clear array of input names */
for (i = 0; i < input; i++)
{
/* Clear name */
learn->input_name[i] = NULL;
}
}
void run_pagerank_csr_mpi(char *file, char *dir)
{
t_list = (t_time_list*)malloc(sizeof(t_time_list));
t_list->list = (t_time_elem*)malloc(sizeof(t_time_elem)*10);
init_timer(t_list, 10);
lint i=0,j=0;
t_buff *buf = (t_buff*)malloc(sizeof(t_buff));
buf->size=buff_size;
buf->buff_idx = (sint**)malloc(sizeof(sint*)*num_threads);
buf->double_buffer = (double***)malloc(sizeof(double**)*num_threads);
buf->int_buffer = (lint***)malloc(sizeof(lint**)*num_threads);
init_t_buff(buf, buf->size);
//data structure for from_msg
lint **idx_start = (lint**)_mm_malloc(sizeof(lint*)*num_nodes, 64);
lint **idx_end = (lint**)_mm_malloc(sizeof(lint*)*num_nodes, 64);
for(i=0;i<num_nodes;i++){
idx_start[i] = (lint*)_mm_malloc(sizeof(lint)*num_threads, 64);
idx_end[i] = (lint*)_mm_malloc(sizeof(lint)*num_threads, 64);
}
//double rand_jump = RDM_JMP/(u/t_msouble)graph->v_size;
double rand_jump = RDM_JMP;
double purpose_jump = 1-RDM_JMP;
lint iter=0;
/* Initialize mpi */
int *argc = (int*)malloc(sizeof(int));
char ***argv = (char***)malloc(sizeof(char**));
//MPI_Init(argc, argv);
sint myrank, size;
MPI_Comm_rank (MPI_COMM_WORLD, &myrank);
MPI_Comm_size (MPI_COMM_WORLD, &size);
// init files
char f_buf[100];
sprintf(f_buf, "%slog/%s_log_%d_%d",dir, file, myrank, num_nodes);
FILE *lg = fopen(f_buf, "w");
//if((lg = fopen(f_buf, "w"))==NULL){
// printf("the file %s does not exists!\n", f_buf);
// ERROR_PRINT();
//}
////////////////////////////////
lint ii, jj;
lint upper_bound, lower_bound;
/* reading graph, init some parameters */
t_csr *gs = (t_csr*)malloc(sizeof(t_csr));
sprintf(f_buf, "%s%s_sd_%d_%d", data_extend, file, myrank, num_nodes);
if(bin==FALSE){
scan_csr_idx(gs, f_buf, dir, SEND);
read_graph_csr(gs, f_buf, dir, SEND);
}
else{
read_csr_bin(gs, f_buf,dir, SEND, myrank);
}
t_csr *gr = (t_csr*)malloc(sizeof(t_csr));
sprintf(f_buf, "%s%s_rc_%d_%d", data_extend, file, myrank, num_nodes);
if(bin==FALSE){
scan_csr_idx(gr, f_buf, dir, RECV);
read_graph_csr(gr, f_buf, dir, RECV);
}
else{
read_csr_bin(gr, f_buf,dir, RECV, myrank);
}
lint *distrib = (lint*)malloc(sizeof(lint)*num_nodes);
if(bin==FALSE){
read_recip(file, dir, distrib, gr, myrank);
if(myrank==0)
printf("%1.10f\n", gr->vet_info[0].recip);
}
else{
read_recip_bin(file, dir, distrib, gr, myrank);
}
init_node_id(gs, distrib, num_nodes);
init_weight(gr);
t_msg *msg = (t_msg*)malloc(sizeof(t_msg));
lower_bound = gr->offset-OFFSET;
upper_bound = gr->v_size+gr->offset-OFFSET;
//printf("%d %d %d \n", myrank, lower_bound, upper_bound);
double *diff_pr = (double*)_mm_malloc(sizeof(double)*gr->v_size, 64);
double *diff_tmp = (double*)_mm_malloc(sizeof(double)*gs->e_size, 64);
lint *pidx_tmp = (lint*)malloc(sizeof(lint)*gs->e_size);
lint *diff_assign = (lint*)malloc(sizeof(lint)*gs->e_size);
lint *idx_tmp = (lint*)malloc(sizeof(lint)*gs->e_size);
lint *node_idx_tmp = (lint*)malloc(sizeof(lint)*gs->e_size);
lint *bin_idx = (lint*)malloc(sizeof(lint)*(1+HASH_BINS));
for(i=0;i<gr->v_size;i++){
diff_pr[i]=gr->vet_info[i].weight * gr->vet_info[i].recip;
}
sprintf(f_buf, "%sparex/%s_pidx_%d_%d", dir, file, myrank, num_nodes);
FILE *reader_pidx;
if((reader_pidx=fopen(f_buf, "r")) == NULL){
printf("the file %s does not exists!\n", f_buf);
ERROR_PRINT();
}
for(i =0; i< gs->e_size; i++){
lint pval;
fscanf(reader_pidx, "%lld\n", &pval);
pidx_tmp[i] = pval;
}
MPI_Barrier(MPI_COMM_WORLD);
for(j=0; j<gs->e_size; j++){
diff_assign[j] = j;
idx_tmp[j] = gs->edge_idx[j];
node_idx_tmp[j] = gs->edge_info[j].node_id;
}
//for(i=0;i<gs->e_size; i++)
// printf("%lld %lld\n", idx_tmp[i], pidx_tmp[i]);
//read pidx_tmp
//partition the msg
partition_msg(diff_assign, pidx_tmp, idx_tmp, bin_idx, node_idx_tmp, gs->e_size);
reverse_diff_assign(diff_assign, gs->e_size);
//sprintf(f_buf, "data/rand/log/2_20_l_%d", myrank);
//FILE *l = fopen(f_buf, "w");
//for(i=0;i<gs->e_size; i++)
// fprintf(l, "%lld\n", diff_assign[i]);
//fprintf(l, "\n");
//fclose(l);
//printf("finished partition\n");
MPI_Barrier(MPI_COMM_WORLD);
lint **send_ub = (lint**)malloc(sizeof(lint*)*num_nodes);
for(i=0;i<num_nodes;i++)
send_ub[i] = (lint*)malloc(sizeof(lint)*num_nodes);
if(bin==FALSE)
read_send_ub(file, dir, send_ub);
else
read_send_ub_bin(file, dir, send_ub);
//if(myrank==0){
// printf("the send ub is\n");
// for(i=0;i<num_nodes; i++){
// for(j=0;j<num_nodes; j++)
// printf("%lld ", send_ub[i][j]);
// printf("\n");
// }
//}
init_msg(msg, send_ub, myrank);
for(ii=0;ii<gr->v_size;ii++)
gr->vet_info[ii].wb = rand_jump;
/* major computation */
#ifdef USE_OMP
omp_set_num_threads(num_threads);
#endif
sint terminate = FALSE;
sint term_buf[10];
sint term[num_nodes];
while(terminate == FALSE){
for(ii=0;ii<num_nodes;ii++)
term[ii]=TRUE;
iter++;
terminate = TRUE;
if(myrank==0){
DPRINTF(1, "ITER %lld ", iter);
for(ii=0;ii<10;ii++){
DPRINTF(1, "%f|%f ", gr->vet_info[ii].wb, gr->vet_info[ii].recip);
}
//DPRINTF(1, "%f|%f ", gr->vet_info[47245].wb, gr->vet_info[53765].recip);
DPRINTF(1, "\n");
}
tic_sr(t_list, 0);
#ifdef USE_OMP
#pragma omp parallel for shared (gs, gr)
#endif
for(ii=0;ii<gr->v_size;ii++){
for(jj=(ii==0?0:gr->vet_idx[ii-1]); jj<gr->vet_idx[ii]; jj++){
lint source = ii;
lint target = gr->edge_idx[jj];
if(target>= lower_bound && target<upper_bound){
gr->vet_info[source].wb+=purpose_jump*diff_pr[target - gr->offset + OFFSET];
// prefetch next target value
lint target_next = gr->edge_idx[jj+prefetch_dis];
_mm_prefetch((char *)(diff_pr + target_next), _MM_HINT_T0);
}
}
}
toc_sr(t_list, 0);
for(ii=0;ii<num_nodes;ii++)
msg->idx_recv[ii]=0;
DPRINTF(3, "node %d, on iter %lld, finished local computation!\n", myrank, iter);
//communication send
sint num_comm = log(num_nodes)/log(2);
sint ic, it;
sint bucket[num_nodes];
sint role[num_nodes];
tic_sr(t_list, 1);
#ifdef USE_SORTMSG
to_msg_no_buf(diff_pr, msg, gs, myrank);
reduce_msg(msg, myrank, send_ub);
#else
assign_diff(diff_tmp, diff_assign, diff_pr, gs, myrank);
set_msg(msg, send_ub, myrank);
to_msg_reduce(diff_tmp, msg, pidx_tmp, idx_tmp, bin_idx, node_idx_tmp);
#endif
toc_sr(t_list, 1);
MPI_Request request_send_int[num_nodes];
MPI_Request request_send_double[num_nodes];
MPI_Request request_recv_int[num_nodes];
MPI_Request request_recv_double[num_nodes];
MPI_Status status;
tic_sr(t_list, 2);
sint msg_iter=1;
#ifdef USE_SYNC
for(it=0;it<msg_iter;it++){
for(ic=0; ic<num_comm; ic++){
compute_bucket_role(bucket, role, ic);
if(role[myrank]==SEND_FIRST){
for(ii=0; ii<num_nodes; ii++){
if(bucket[ii]!=bucket[myrank] || role[ii]!=RECV_FIRST){
continue;
}
//odd send to even then recv from even
lint send_avg = send_ub[myrank][ii]/msg_iter+1;
lint send_start = send_avg*it;
lint send_size = (send_ub[myrank][ii]-send_start)>=send_avg?send_avg:(send_ub[myrank][ii]-send_start);
//printf("myrank %d, to %lld msg_iter %d avg:%lld start:%lld size:%lld ub: %lld\n", myrank, ii, it, send_avg, send_start, send_size, send_ub[myrank][ii]);
MPI_Send(msg->double_send[ii]+send_start, send_size, MPI_DOUBLE, ii, 2, MPI_COMM_WORLD );
MPI_Send(msg->int_send[ii]+send_start, send_size, MPI_LONG_LONG, ii, 0, MPI_COMM_WORLD);
lint recv_avg = send_ub[ii][myrank]/msg_iter+1;
lint recv_start = recv_avg*it;
lint recv_size = (send_ub[ii][myrank]-recv_start)>=recv_avg?recv_avg:(send_ub[ii][myrank]-recv_start);
MPI_Recv(msg->double_recv[ii]+recv_start, recv_size, MPI_DOUBLE, ii, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(msg->int_recv[ii]+recv_start, recv_size, MPI_LONG_LONG, ii, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
msg->idx_recv[ii]=send_ub[ii][myrank];
//if(iter==1 && myrank==0 && ii==1)
// printf("send ub %lld %lld\n", send_ub[ii][myrank], recv_size);
//if(myrank==0 && ii==1 && iter ==1)
// for(i=0;i<recv_size;i++)
// printf("%d %lld\n", i+recv_start, msg->int_recv[ii][i+recv_start]);
}
}
else if(role[myrank]==RECV_FIRST){
for(ii=0; ii<num_nodes; ii++){
if(bucket[ii]!=bucket[myrank] || role[ii]!=SEND_FIRST){
continue;
}
//even recv from odd then send to odd
lint recv_avg = send_ub[ii][myrank]/msg_iter+1;
lint recv_start = recv_avg*it;
lint recv_size = (send_ub[ii][myrank]-recv_start)>=recv_avg?recv_avg:(send_ub[ii][myrank]-recv_start);
//if(myrank==1 && ii==0)
//printf("myrank %d, to %lld msg_iter %d avg:%lld start:%lld size:%lld ub: %lld\n", myrank, ii, it, recv_avg, recv_start, recv_size, send_ub[ii][myrank]);
MPI_Recv(msg->double_recv[ii]+recv_start, recv_size, MPI_DOUBLE, ii, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Recv(msg->int_recv[ii]+recv_start, recv_size, MPI_LONG_LONG, ii, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
lint send_avg = send_ub[myrank][ii]/msg_iter+1;
lint send_start = send_avg*it;
lint send_size = (send_ub[myrank][ii]-send_start)>=send_avg?send_avg:(send_ub[myrank][ii]-send_start);
MPI_Send(msg->double_send[ii]+send_start, send_size, MPI_DOUBLE, ii, 2, MPI_COMM_WORLD);
MPI_Send(msg->int_send[ii]+send_start, send_size, MPI_LONG_LONG, ii, 0, MPI_COMM_WORLD);
msg->idx_recv[ii]=send_ub[ii][myrank];
}
}
//MPI_Barrier(MPI_COMM_WORLD);
}
}
#else
for(it=0;it<msg_iter;it++){
for(ii=0;ii<num_nodes;ii++){
if(ii==myrank)
continue;
lint send_avg = send_ub[myrank][ii]/msg_iter+1;
lint send_start = send_avg*it;
lint send_size = (send_ub[myrank][ii]-send_start)>=send_avg?send_avg:(send_ub[myrank][ii]-send_start);
MPI_Isend(msg->double_send[ii]+send_start, send_size, MPI_DOUBLE, ii, 2, MPI_COMM_WORLD, &(request_send_double[ii]));
MPI_Isend(msg->int_send[ii]+send_start, send_size, MPI_LONG_LONG, ii, 0, MPI_COMM_WORLD, &(request_send_int[ii]));
}
}
for(it=0;it<msg_iter;it++){
for(ii=0;ii<num_nodes;ii++){
if(ii==myrank)
continue;
lint recv_avg = send_ub[ii][myrank]/msg_iter+1;
lint recv_start = recv_avg*it;
lint recv_size = (send_ub[ii][myrank]-recv_start)>=recv_avg?recv_avg:(send_ub[ii][myrank]-recv_start);
MPI_Irecv(msg->double_recv[ii]+recv_start, recv_size, MPI_DOUBLE, ii, 2, MPI_COMM_WORLD, &(request_recv_double[ii]));
MPI_Irecv(msg->int_recv[ii]+recv_start, recv_size, MPI_LONG_LONG, ii, 0, MPI_COMM_WORLD, &(request_recv_int[ii]));
msg->idx_recv[ii]=send_ub[ii][myrank];
}
//printf("come here\n");
}
//printf("before log\n");
for(ii=0;ii<num_nodes;ii++){
if(ii == myrank)
continue;
MPI_Wait(&(request_send_double[ii]), &status);
MPI_Wait(&(request_recv_double[ii]), &status);
MPI_Wait(&(request_send_int[ii]), &status);
MPI_Wait(&(request_recv_int[ii]), &status);
}
//printf("see log!\n");
//for(ii=0;ii<num_nodes;ii++){
//}
#endif
//if(iter==1){
// sprintf(f_buf, "/home/yinzhaom/SNY/data/log/log_%d", myrank);
// FILE *logfile = fopen(f_buf, "w");
// int node, vet;
// for(node=0;node<num_nodes;node++){
// if(node==myrank)
// continue;
// fprintf(logfile, "from node %d\n", node);
// for(vet=0;vet<send_ub[node][myrank];vet++)
// fprintf(logfile, "%d %lld %lf\n", vet, msg->int_recv[node][vet], msg->double_recv[node][vet]);
// }
//}
//printf("finished msg passing of rank %d\n", myrank);
toc_sr(t_list, 2);
if(myrank==0){
for (jj=0;jj<num_nodes;jj++)
DPRINTF(3, "%lld ", msg->idx_recv[jj]);
DPRINTF(3, "\n");
}
/////////////communication recv////////////////////
tic_sr(t_list, 3);
from_msg(msg, gr, myrank,send_ub, purpose_jump, idx_start, idx_end);
toc_sr(t_list, 3);
//printf("FINIHSED from msg of rank %d\n", myrank);
//if(iter==1)
// pp_msg(msg, gr, myrank,send_ub, purpose_jump);
//////////////////check termination//////////////
tic_sr(t_list, 4);
for(ii=0;ii<gr->v_size;ii++){
diff_pr[ii]=(gr->vet_info[ii].wb - gr->vet_info[ii].weight)*gr->vet_info[ii].recip;
}
for(ii=0;ii<gr->v_size;ii++){
if(fabs(diff_pr[ii])>THRESH)
terminate = FALSE;
gr->vet_info[ii].weight = gr->vet_info[ii].wb;
}
term_buf[0]=terminate;
for(ii=0; ii<num_nodes; ii++){
if(ii==myrank)
continue;
MPI_Send(term_buf, 10, MPI_INT, ii, 1, MPI_COMM_WORLD);
}
for(ii=0; ii<num_nodes; ii++){
if(ii==myrank)
continue;
MPI_Recv(term_buf, 10, MPI_INT, ii, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
term[ii]=term_buf[0];
}
term[myrank] = terminate;
for(ii=0;ii<num_nodes;ii++)
if(term[ii]==FALSE)
terminate = FALSE;
if(terminate == TRUE)
break;
toc_sr(t_list, 4);
//printf("finished check termination of rank %d\n", myrank);
}
if(myrank==MASTER){
DPRINTF(1, "Final pagerank values: \n");
for(ii=0;ii<10;ii++){
DPRINTF(1, "%lld|%lf ", (ii+gr->offset), gr->vet_info[ii].weight);
}
DPRINTF(1, "\n");
}
if(myrank==MASTER){
printf("iterations taken: %lld\n", iter);
lint recv_size=0;
for(i=0;i<num_nodes;i++){
if(i==myrank)
continue;
recv_size += send_ub[i][myrank];
}
print_result(t_list, iter, gs->e_size, recv_size);
}
/* Shut down mpi */
MPI_Finalize();
//fclose(lg);
}
