int MPI_Reduce(void* input_data_p,void* output_data_p,int count,
MPI_Datatype datatype,MPI_Op operator,int dest_process,MPI_Comm comm);

#include<mpi.h>
#include<bits/stdc++.h>
#include<sys/time.h>
using namespace std;

int main(int argc,char** argv){
  int comm_sz,my_rank;
  MPI_Init(NULL,NULL);
  MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
  MPI_Comm_size(MPI_COMM_WORLD,&comm_sz);
  int val=my_rank*my_rank,sum=0;
  MPI_Reduce(&val,&sum,1,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD);
  if(my_rank==0){cout<<sum<<endl;}
  MPI_Finalize();
}

int MPI_Allreduce(void* input_data_p,void* output_data_p,int count,
MPI_Datatype datatype,MPI_OP operator,MPI_Comm comm);

#include<mpi.h>
#include<bits/stdc++.h>
#include<sys/time.h>
using namespace std;

int main(int argc,char** argv){
  int comm_sz,my_rank;
  MPI_Init(NULL,NULL);
  MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
  MPI_Comm_size(MPI_COMM_WORLD,&comm_sz);
  int val=my_rank*my_rank,sum=0;
  MPI_Allreduce(&val,&sum,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
  cout<<sum<<endl;
  MPI_Finalize();
}

int MPI_Bcast(void* data_p,int count,MPI_Datatype datatype,int souce_proc,MPI_Comm comm);

#include<mpi.h>
#include<bits/stdc++.h>
#include<sys/time.h>
using namespace std;

int main(int argc,char** argv){
  int comm_sz,my_rank;
  MPI_Init(NULL,NULL);
  MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
  MPI_Comm_size(MPI_COMM_WORLD,&comm_sz);
  
  if(my_rank==0){
    char* s="hello world!\n";
    MPI_Bcast(s,strlen(s)+1,MPI_CHAR,0,MPI_COMM_WORLD);
  }
  else{
    char *s=(char*)malloc(100*sizeof(char));
    MPI_Bcast(s,14,MPI_CHAR,0,MPI_COMM_WORLD);//注意，这里s还是空字符串，不能用strlen确定长度。
    printf("In process %d,s is %s",my_rank,s);
    free(s);
  }
  MPI_Finalize();
}

int MPI_Scatter(void* send_buf_p,int send_count,
MPI_Datatype send_type,void* recv_buf_p,int recv_count,
MPI_Datatype recv_type,int src_proc,MPI_Comm comm);

#include<mpi.h>
#include<bits/stdc++.h>
#include<sys/time.h>
using namespace std;

int main(int argc,char** argv){
  int comm_sz,my_rank;
  MPI_Init(NULL,NULL);
  MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
  MPI_Comm_size(MPI_COMM_WORLD,&comm_sz);
  int n=100;
  int* b=(int*)malloc(n/comm_sz*sizeof(int));
  if(my_rank==0){
    int* a=(int*)malloc(n*sizeof(int));
    for(int i=0;i<n;i++){
      a[i]=i;
    }
    MPI_Scatter(a,n/comm_sz,MPI_INT,b,n/comm_sz,MPI_INT,0,MPI_COMM_WORLD);
  }
  else{
    MPI_Scatter(NULL,n/comm_sz,MPI_INT,b,n/comm_sz,MPI_INT,0,MPI_COMM_WORLD);
  }
  for(int i=0;i<n/comm_sz;i++)printf("In process %d, b[%d]=%d\n",my_rank,i,b[i]);
  MPI_Finalize();
}

int MPI_Gather(void* send_buf_p,int send_count,MPI_Datatype send_type,void* recv_buf_p,
int recv_count,MPI_Datatype recv_type,int dest_proc,MPI_Comm comm);

int MPI_Gather(void* send_buf_p,int send_count,MPI_Datatype send_type,void* recv_buf_p,
int recv_count,MPI_Datatype recv_type,int dest_proc,MPI_Comm comm);

#include<mpi.h>
#include<bits/stdc++.h>
#include<sys/time.h>
using namespace std;

void my_rand(double* vec,int size){
  for(int i=0;i<size;i++)vec[i]=(double)rand()/RAND_MAX;
}

void Mat_vec_mul2(double* local_A,double* x,double* local_y,int local_m,int n,int local_n,MPI_Comm comm){
  int local_i,j,local_ok=1;
  for(local_i=0;local_i<local_m;local_i++){
    local_y[local_i]=0.0;
    for(j=0;j<n;j++)local_y[local_i]+=local_A[local_i*n+j]*x[j];
  }
}
int main(int argc,char** argv){
  int comm_sz,my_rank;
  MPI_Init(NULL,NULL);
  MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);
  MPI_Comm_size(MPI_COMM_WORLD,&comm_sz);

  int m,n,local_m,local_n;
  if(argc!=3)abort();
  sscanf(argv[1],"%d",&m);
  sscanf(argv[2],"%d",&n);
  local_m=m/comm_sz,local_n=n/comm_sz;
  double* local_A,* local_x,* local_y;
  local_A=(double*)malloc(local_m*n*sizeof(double));
  local_x=(double*)malloc(local_n*sizeof(double));
  local_y=(double*)malloc(local_m*sizeof(double));
  double *x=(double*)malloc(n*sizeof(double));
  if(my_rank==0){
    struct timeval tv,tv2;
    gettimeofday(&tv,NULL);

    double* A=(double*)malloc(m*n*sizeof(double));
    double* y=(double*)malloc(m*sizeof(double)),*y2=(double*)malloc(m*sizeof(double));
    my_rand(A,m*n),my_rand(x,n);
    MPI_Scatter(A,local_m*n,MPI_DOUBLE,local_A,local_m*n,MPI_DOUBLE,0,MPI_COMM_WORLD);
    MPI_Bcast(x,n,MPI_DOUBLE,0,MPI_COMM_WORLD);
    Mat_vec_mul2(local_A,x,local_y,local_m,n,local_n,MPI_COMM_WORLD);
    MPI_Gather(local_y,local_m,MPI_DOUBLE,y,local_m,MPI_DOUBLE,0,MPI_COMM_WORLD);

    gettimeofday(&tv2,NULL);
    printf("time: %d\n",tv2.tv_sec*1000000 + tv2.tv_usec - tv.tv_sec*1000000 - tv.tv_usec);
    //  for(int i=0;i<m;i++)cout<<y[i]<<" "<<y2[i]<<endl;
    free(A),free(y),free(y2);
  }
  else{
    MPI_Scatter(NULL,local_m*n,MPI_DOUBLE,local_A,local_m*n,MPI_DOUBLE,0,MPI_COMM_WORLD);
    MPI_Bcast(x,n,MPI_DOUBLE,0,MPI_COMM_WORLD);
    Mat_vec_mul2(local_A,x,local_y,local_m,n,local_n,MPI_COMM_WORLD);
    MPI_Gather(local_y,local_m,MPI_DOUBLE,NULL,local_m,MPI_DOUBLE,0,MPI_COMM_WORLD);
  }
  free(local_A);free(local_y);free(x);
}

int MPI_Type_create_struct(int count,int array_of_clocklengths[],
MPI_Aint array_of_displacements[],MPI_Datatype array_of_types[],MPI_Datatype* new_type_p);

int a;
double b,c;
MPI_Aint a_addr,b_addr,c_addr;
MPI_Get_address(&a,&a_addr);
MPI_Get_address(&b,&b_addr);
MPI_Get_address(&c,&c_addr);
MPI_Aint array_of_displacements[3]={0,b_addr-a_addr,c_addr-a_addr};
int array_of_blocklengths[3]={1,1,1};
MPI_Datatype array_of_types[3]={MPI_INT,MPI_DOUBLE,MPI_DOUBLE};
MPI_Datatype input_mpi_t;
MPI_Type_create_struct(3,array_of_blocklengths,array_of_displacements,array_of_types,&input_mpi_t);
MPI_Type_commit(&input_mpi_t);

  if(my_rank==0){
    a=1,b=1.1,c=2.2;
    MPI_Bcast(&a,1,input_mpi_t,0,MPI_COMM_WORLD);
  }
else{
    MPI_Bcast(&a,1,input_mpi_t,0,MPI_COMM_WORLD);
    printf("In process %d: a=%d b=%f c=%f\n",my_rank,a,b,c);
}

sum+=factor/(2*i+1);

while(flag!=my_rank);
sum+=factor/(2*i+1);
flag=(flag+1)%thread_count;

void* Thread_sum(void* rank){
  long my_rank=(long)rank;
  double my_sum=0;
  double factor;
  long long i;
  long long my_n=n/thread_count;
  long long my_first_i=my_n*my_rank;
  long long my_last_i=my_first_i+my_n;

  if(my_first_i%2==0){
    factor=1.0;
  }
  else factor=-1.0;
  for(i = my_first_i;i<my_last_i;i++,factor=-factor){
//    printf("%d %d\n",flag,my_rank);
    my_sum+=factor/(2*i+1);
  }
  while(flag!=my_rank);
  sum+=my_sum;
  flag=(flag+1)%thread_count;
  return NULL;
}

#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/time.h>
int thread_count,n;
double sum;
int flag;
pthread_mutex_t mutex;
void* Thread_sum(void* rank){
  long my_rank=(long)rank;
  double my_sum=0;
  double factor;
  long long i;
  long long my_n=n/thread_count;
  long long my_first_i=my_n*my_rank;
  long long my_last_i=my_first_i+my_n;

  if(my_first_i%2==0){
    factor=1.0;
  }
  else factor=-1.0;
  for(i = my_first_i;i<my_last_i;i++,factor=-factor){
//    printf("%d %d\n",flag,my_rank);
    my_sum+=factor/(2*i+1);
  }
  pthread_mutex_lock(&mutex);
  sum+=my_sum;
  pthread_mutex_unlock(&mutex);
  return NULL;
}

int main(int argc,char** argv){
  if(argc!=3)abort();
  long thread;
  pthread_t* thread_handles;
  thread_count=strtol(argv[1],NULL,10);
  n=strtol(argv[2],NULL,10);
  pthread_mutex_init(&mutex,NULL);
  struct timeval tv,tv2;
  gettimeofday(&tv,NULL);
  thread_handles=malloc(thread_count*sizeof(pthread_t));
  for(thread=0;thread<thread_count;thread++)pthread_create(&thread_handles[thread],NULL,Thread_sum,(void*)thread);
  //printf("Hello from the main thread\n");
  for(thread=0;thread<thread_count;thread++)pthread_join(thread_handles[thread],NULL);
//  for(int i=0;i<m;i++)printf("%f\n",y[i]);
  free(thread_handles);
  pthread_mutex_destroy(&mutex);
  gettimeofday(&tv2,NULL);
  printf("ans: %.8f\n",4*sum);
  printf("%d\n",tv2.tv_sec*1000000 + tv2.tv_usec - tv.tv_sec*1000000 - tv.tv_usec);

  return 0;
}

#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/time.h>
int thread_count,n,m;
double** A,*x,*y;

void* Pth_mat_vect(void* rank){
  long my_rank=(long)rank;
  int i,j,local_m=m/thread_count;
  int my_first_row=my_rank*local_m,my_last_row=my_first_row+local_m;
  for(i=my_first_row;i<my_last_row;i++){
    double tem=0.0,*A2=A[i];
    for(j=0;j<n;j++){
      tem+=A2[j]*x[j];
    }
    y[i]=tem;
  }
  return NULL;
}

int main(int argc,char** argv){
  freopen("out2.txt","a",stdout);
  if(argc!=4)abort();
  long thread;
  pthread_t* thread_handles;
  thread_count=strtol(argv[1],NULL,10);
  m=strtol(argv[2],NULL,10);
  n=strtol(argv[3],NULL,10);

  A=(double**)malloc(m*sizeof(double*));
  for(int i=0;i<m;i++)A[i]=(double*)malloc(n*sizeof(double));
  x=(double*)malloc(n*sizeof(double));
  y=(double*)malloc(m*sizeof(double));
  for(int i=0;i<m;i++){
    for(int j=0;j<n;j++){
      A[i][j]=(double)rand()/RAND_MAX;
    }
  }
  for(int i=0;i<n;i++)x[i]=(double)rand()/RAND_MAX;

  struct timeval tv,tv2;
  gettimeofday(&tv,NULL);
  thread_handles=malloc(thread_count*sizeof(pthread_t));
  for(thread=0;thread<thread_count;thread++)pthread_create(&thread_handles[thread],NULL,Pth_mat_vect,(void*)thread);
  //printf("Hello from the main thread\n");
  for(thread=0;thread<thread_count;thread++)pthread_join(thread_handles[thread],NULL);
//  for(int i=0;i<m;i++)printf("%f\n",y[i]);
  gettimeofday(&tv2,NULL);
  printf("%d\n",tv2.tv_sec*1000000 + tv2.tv_usec - tv.tv_sec*1000000 - tv.tv_usec);

  free(thread_handles);
  for(int i=0;i<m;i++)free(A[i]);
  free(A),free(x),free(y);

  return 0;
}

#include<iostream>
#include<mpi.h>
using namespace std;
int main(int argc,char **argv){
    int numprocs, myid;
    MPI_Status status;
    MPI_Init(&argc, &argv);//
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);//这里myid表示这个进程是第几个进程，如果myid是0则是第一个进程
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);  //numprocs表示总的进程数量
    cout<<"helloworld\n";
    MPI_Finalize();//
}

#include<iostream>
#include<mpi.h>
#include<algorithm>
using namespace std;
const int MAX_size=1e7;
int main(int argc,char** argv){
    int numprocs, myid, source;
    MPI_Status status;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);  
    int siz=MAX_size/2;
    if(myid==0){
      int *nums=new int[MAX_size+3];
      for(int i=0;i<MAX_size;i++){
        nums[i]=rand();
      }
      int t1=clock();
      MPI_Send(nums,siz,MPI_INT,1,1,MPI_COMM_WORLD);
      MPI_Send(nums+siz,siz,MPI_INT,2,2,MPI_COMM_WORLD);
      int* rec1=new int[siz+3],*rec2=new int[siz+3];
      MPI_Recv(rec1,siz,MPI_INT,1,1,MPI_COMM_WORLD,&status);
      MPI_Recv(rec2,siz,MPI_INT,2,2,MPI_COMM_WORLD,&status);
      int i=0,j=0,loc=0;
      while(i<siz&&j<siz){
        if(rec1[i]<rec2[j])nums[loc++]=rec1[i++];
        else nums[loc++]=rec2[j++];
      }
      while(i<siz)nums[loc++]=rec1[i++];
      while(j<siz)nums[loc++]=rec2[j++];
      int t2=clock();
      cout<<t2-t1<<endl;
    }
    else{
      int* rec=new int[siz+3];
      MPI_Recv(rec,siz,MPI_INT,0,myid,MPI_COMM_WORLD,&status);
      sort(rec,rec+siz);
      MPI_Send(rec,siz,MPI_INT,0,myid,MPI_COMM_WORLD);
    }
    MPI_Finalize();
}

#include<iostream>
#include <mpi.h>
#include<algorithm>
using namespace std;
const int MAX_size=1e7;
int get_state(int myid){
  if(myid==0)return 1;
  else if(myid<3)return 0;
  else return -1;
}
int main(int argc, char* argv[])
{
    int numprocs, myid, source;
    MPI_Status status;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
    int state=get_state(myid);
    if(state==1){
      int* nums=new int[MAX_size+3];
      int son1=(myid<<1)+1,son2=(myid<<1)+2;
      for(int i=0;i<MAX_size;i++)nums[i]=rand();
      int t1=clock();
      MPI_Send(nums,MAX_size/2,MPI_INT,son1,myid*numprocs+son1,MPI_COMM_WORLD);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      MPI_Send(nums+MAX_size/2,MAX_size/2,MPI_INT,son2,myid*numprocs+son2,MPI_COMM_WORLD);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      int* rec1=new int[MAX_size/2+3],*rec2=new int[MAX_size/2+3];
      MPI_Recv(rec1,MAX_size/2,MPI_INT,son1,myid*numprocs+son1,MPI_COMM_WORLD,&status);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      MPI_Recv(rec2,MAX_size/2,MPI_INT,son2,myid*numprocs+son2,MPI_COMM_WORLD,&status);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      int i=0,j=0,size=MAX_size/2,loc=0;
      while(i<size&&j<size){
        if(rec1[i]<rec2[j]){
          nums[loc++]=rec1[i++];
        }
        else{
          nums[loc++]=rec2[j++];
        }
      }
      while(i<size){nums[loc++]=rec1[i++];}
      while(j<size){nums[loc++]=rec2[j++];}
//      for(int i=0;i<MAX_size;i++)cout<<nums[i]<<endl;
      int t2=clock();
      cout<<t2-t1<<endl;
    }

    else if(state==0){
      int* nums=new int[MAX_size/2+3];
      int* rec1=new int[MAX_size/4+3],*rec2=new int[MAX_size/4+3];
      int son1=(myid<<1)+1,son2=(myid<<1)+2,fa=(myid-1)>>1;
      MPI_Recv(nums,MAX_size/2,MPI_INT,fa,fa*numprocs+myid,MPI_COMM_WORLD,&status);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      MPI_Send(nums,MAX_size/4,MPI_INT,son1,myid*numprocs+son1,MPI_COMM_WORLD);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      MPI_Send(nums+MAX_size/4,MAX_size/4,MPI_INT,son2,myid*numprocs+son2,MPI_COMM_WORLD);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      MPI_Recv(rec1,MAX_size/4,MPI_INT,son1,myid*numprocs+son1,MPI_COMM_WORLD,&status);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      MPI_Recv(rec2,MAX_size/4,MPI_INT,son2,myid*numprocs+son2,MPI_COMM_WORLD,&status);
      //cout<<myid<<" "<<son1<<" "<<son2<<endl;
      int i=0,j=0,size=MAX_size/4,loc=0;
      while(i<size&&j<size){
        if(rec1[i]<rec2[j]){
          nums[loc++]=rec1[i++];
        }
        else{
          nums[loc++]=rec2[j++];
        }
      }
      while(i<size){nums[loc++]=rec1[i++];}
      while(j<size){nums[loc++]=rec2[j++];}
      MPI_Send(nums,MAX_size/2,MPI_INT,fa,fa*numprocs+myid,MPI_COMM_WORLD);
    }

    else{
      int* nums=new int[MAX_size/4+3];
      int fa=(myid-1)>>1;
      MPI_Recv(nums,MAX_size/4,MPI_INT,fa,fa*numprocs+myid,MPI_COMM_WORLD,&status)；
//      cout<<myid<<endl;
      sort(nums,nums+MAX_size/4);
      MPI_Send(nums,MAX_size/4,MPI_INT,fa,fa*numprocs+myid,MPI_COMM_WORLD);
    }
//    cout<<"??\n";
    MPI_Finalize();
  //  cout<<myid<<"end\n";
} /* end main */

#include<iostream>
#include<algorithm>
#include<mpi.h>
const int MAX_size=1e7;
using namespace std;
int main(int argc,char** argv){
    int numprocs, myid, source;
    MPI_Status status;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);  
    int sub_size=MAX_size/(numprocs-1);
    int siz[104]={0};
    for(int i=1;i<numprocs;i++)siz[i]=MAX_size/(numprocs-1);
    for(int i=1;i<=MAX_size%(numprocs-1);i++)siz[i]++;
    if(!myid){
      int* num=new int[MAX_size];
      for(int i=0;i<MAX_size;i++)num[i]=rand();
      int t1=clock();
      int loc[numprocs]={0};
      for(int i=1,*tem=num;i<numprocs;i++,tem+=siz[i]){
  //      cout<<i<<endl;
        MPI_Send(tem,siz[i],MPI_INT,i,i,MPI_COMM_WORLD);
      }
      int** ans=new int*[numprocs];
//      cout<<"??\n";
      for(int i=1;i<numprocs;i++){
        ans[i]=new int[siz[i]+3];
        MPI_Recv(ans[i],siz[i],MPI_INT,i,i,MPI_COMM_WORLD,&status);
      }
      for(int i=0;i<MAX_size;i++){
        int minval=(1ll<<31)-1,locc=0;
        for(int i=1;i<numprocs;i++){
          if(loc[i]<siz[i]&&ans[i][loc[i]]<minval)minval=ans[i][loc[i]],locc=i;
        }
        num[i]=minval,loc[locc]++;
      }
      int t2=clock();
      cout<<t2-t1<<endl;
    }
    else{
      int* num=new int[siz[myid]+3];
      MPI_Recv(num,siz[myid],MPI_INT,0,myid,MPI_COMM_WORLD,&status);
      sort(num,num+siz[myid]);
      MPI_Send(num,siz[myid],MPI_INT,0,myid,MPI_COMM_WORLD);
    }
    MPI_Finalize();

}

typedef struct byte//用byte和bt来表示字节
{
    char s[9];//把字节用01字符串表示
    char h, l;//把字节用16进制表示，h为高4位，l为低4位
    uc ascii;//这个字节的值，uc是unsigned char
    void input();//从输入流中读取一个字节
    void from_char(char c);
} bt;

typedef struct Sector
{
    bt bs[SIZE_OF_SECTOR];//SIZE_OF_SECTOR默认是512
    void input();//从输入流中读取扇区
    void input_from_string(string a);//从一个长为512的字符串中读取扇区
    void output();//打印扇区内容，方便调试
    bt operator[](int i);//按下标取出一个字节
} sector;

struct MBR:public sector{
    char BS_OEMName[8]; // OEM字符串，必须为8个字符，不足以空格填空 
    short BPB_BytsPerSec; // 每扇区字节数 
    char BPB_SecPerClus; // 每簇占用的扇区数 
    short BPB_RsvdSecCnt; // Boot占用的扇区数 
    char BPB_NumFATs; // FAT表的记录数 
    short BPB_RootEntCnt; // 最大根目录文件数 
    short BPB_TotSec16; // 扇区总数 
    char BPB_Media; // 媒体描述符 
    short BPB_FATSz16; // 每个FAT占用扇区数 
    short BPB_SecPerTrk; // 每个磁道扇区数 
    short BPB_NumHeads; // 磁头数 
    int BPB_HiddSec; // 隐藏扇区数 
    int BPB_TotSec32; // 如果BPB_TotSec16是0，则在这里记录 
    char BS_DrvNum; // 中断13的驱动器号 
    char BS_Reserved1; // 未使用 
    char BS_BootSig; // 扩展引导标志 
    int BS_VolID; // 卷序列号 
    char BS_VolLab[11]; // 卷标，必须是11个字符，不足以空格填充 
    char BS_FileSysType[8];// 文件系统类型，8个字符，不足填充空格

    void init();//用于读入后初始化各个变量
    bool check();//用于检查MBR是否合法
    void print(int& Byte_Per_Sector,int& Sector_Per_Cluster,int& Num_Of_Fats,int& Root_Entry_Count,int& Num_Of_Sector,int& Size_Of_Fat,int& Sector_Hidden);//用于显示提示信息
};

typedef struct Fat
{
    vector<bt> bts;//存储fat表的每一个字节
    bt operator[](int i) { return bts[i]; }//按下标访问fat表中的字节
    vector<int> cluster_numbers;//将fat表转换成一个整数数组，前三个字节没有包含在内
    void init(MBR mbr);/*初始化，由于fat表的实际长度是大于数据区扇区数的，所以要将后面一部分切掉，这
    个长度需要MBR中的一些变量来确定*/
    int get_first_empty();//从fat表中读出一个空的簇号
    void write_floopy();//将fat表写回软盘
    int get_empty();//得到fat表中有多少个未被使用的簇和坏簇，用于检查是否有"孤魂野鬼"簇
} fat;

typedef struct RootEntry
{
    vector<bt> bts;

} rootentry;

typedef struct Datas
{
    vector<sector> secs;
    void write_floopy(int clus_num, string content);/*这个函数用于写回软盘
    在程序种写回软盘是以扇区为单位的。第一个参数表示写的是数据区第几个扇区，content是一个512字节的数组表示要写的内容。*/
} datas;

typedef struct File
{
    string content, path;//分别是文件的内容和路径
    string name, suffix;//分别是名字和后缀。文件夹没有后缀
    int attr, fstclus, size;//分别是属性，首簇号，大小。文件夹的属性是0x10,普通文件的属性是0x00。
    unsigned short Time, Date;//文件上一次修改的时间和日期
    File *fa;//它的上一级文件夹的指针。
    map<string, File *> sons;/*只有文件夹才有sons这个成员。
    记录了它的子文件和子文件夹，用名字+"."+后缀来当索引*/
    File() {}//默认构造函数
    File(string Name, File *now);/*这个构造函数用于给now这个指针指向的文件夹
    添加一个子文件夹，Name指定了文件夹的名字*/
    File(string Name, string Content, File *now);/*这个构造函数用于给now这个指针指向的文件夹
    添加一个子文件，Name指定了文件的名字和后缀*/
    File(File *from);/*这个构造函数用于创建于from指向的文件内容相同的文件*/
    unsigned short get_Time(int h, int m);//获得时间
    unsigned short get_Date(int y, int m, int d);//获得日期
    string ToString();//将时间和日期转换成string格式
    string to_file_record();//根据文件的信息得到文件的文件记录
    string to_dir_record();//根据文件夹的信息得到文件夹的文件记录
    void add_file(File *tem_file);//给文件夹添加一个子文件
    void add_file_root(File *tem_file);//跟根目录添加一个子文件
    void get_content();//得到文件的内容
    void write_back(int loc);//将修改后的文件内容写回软盘
    File *get_son(string Name, bool isn_folder);//根据名字和后缀得到一个子文件(夹)
    void dir();//输出子文件的信息
    vector<string> dir_recusive();//递归得到所有子文件的信息
    void remove();//删除这个文件
    void get_content_deleted(int loc);/*对文件夹里已经被删除的目录项调用这个函数，
    使得被删除的簇能被捕获，避免出现"孤魂野鬼"*/
    void find_string(int loc, vector<string> &b, vector<string> &ret);/*从这个文件夹开始查找
    将输入的字符串转化成b,将返回的路径字符串放在ret里*/
    void create(File *tem);//用于创建于tem指向的文件内容相同的文件//
} file;

file *path_analysis(string input, file *now, file *root)
{
    if (input == "")
        return NULL;
    bool rt = (input[0] == '/');
    for (auto i : input)
    {
        if (!isalpha(i) && !isdigit(i) && i != '/' && i != '.')
        {
            return NULL;
        }
    }
    vector<string> folder_names = path_analysis2(input);
    file *tem;
    if (rt)
        tem = root;
    else
        tem = now;
    for (int i = 0; i < folder_names.size(); i++)
    {
        tem = tem->get_son(folder_names[i], i + 1 == folder_names.size());
        if (tem == NULL)
        {
            return NULL;
        }
    }
    return tem;
}

else if (a == "cd")
{
    cin >> b;
    file *now = path_analysis(b, tem, root);
    if (now == NULL || now->attr != 0x10)
    {
        cout << "路径" << b << "不合法\n";
        //注意，cd只能进入文件夹，进入一个文件是不可以的
    }
    else
    {
        tem = now;
    }
}

vector<string> File::dir_recusive()
{
    vector<string> vec, tem;
    vec.push_back(name + (attr == 0x10 ? "" : "." + suffix) + "\n");
    for (auto i : sons)
    {
        if (i.first == "." || i.first == "..")
            continue;
        tem = i.second->dir_recusive();
        for (int j = 0; j < tem.size(); j++)
        {
            vec.push_back("  " + tem[j]);
        }
    }
    return vec;
}

while (!Content.empty())
{
    if (Content.size() > 512)
    {
        datas1.write_floopy(nowclus - 2, Content.substr(0, 512));
        Content = Content.substr(512);
        fat1.cluster_numbers[nowclus - 2] = fat1.get_first_empty() + 2;
        nowclus = fat1.cluster_numbers[nowclus - 2];
        fat1.cluster_numbers[nowclus - 2] = END_CLUSTER;
    }
    else
    {
        datas1.write_floopy(nowclus - 2, Content);
        Content = "";
        fat1.cluster_numbers[nowclus - 2] = END_CLUSTER;
    }
}

void File::remove()
{
    if (attr == 0x10)
    {
        for (auto i : sons)
        {
            if (i.first == "." || i.first == "..")
                continue;
            i.second->remove();
        }
    }

    for (int j = 0; j < fa->content.size(); j += 32)
    {
        if ((fa->content[j + 27] << 8) + fa->content[j + 26] == fstclus)
        {
            fa->content[j] = DELETED_CLUSTER_SIGN;
            fa->sons.erase(attr == 16 ? name : name + "." + suffix);
            fa->write_back(j / SIZE_OF_SECTOR);
            deleted_clusters.push({fa, j / 32});
            break;
        }
    }
}