i need argument research paper about saudi woman driving. i have my resources and my thesis. the research is gonna be 5 papers in present tense i(ntroduction – 3 bodies- conclusion)

discussion two paragraphs MLA format (directions below)

Twain, Mark. “The Damned Human Race.” Moodyap.pbworks.com. n.d. Web. 11 May 2012.

In your discussion, state the purpose of the reading and cite the thesis statement (if applicable). If there is no explicit thesis, state the reading’s claim. Then, lay out the structure of the reading to the class, and let the class know if this structure is organized and logical (you may claim that it is not organized – it’s up to you). Let the reader know how this method of organization helps or does not help the author’s purpose. Then, discuss the style of writing – does the style help the author prove his/her point? Finally, study the introduction and conclusion of your chosen reading. Explain how the author ‘hooks’ the reader in, or, conversely, if the introduction is not strong, explain why. Discuss the conclusion of the essay as well, and point out its strengths and weaknesses. Please answer these questions fully in your response (use thoughtful sentences). It must include MLA citations – both in-text and an end citation. Please also respond to two of your classmates’ initial posts (students who have discussed different essays) and bring together pieces of the discussion and take those ideas further.

Hello everyone,

I have a 3 pages writing home work a bout coversation partner program 

my partnar deatail:-

studying political scinse and finance 

she born in poland 

came to USA from her high school

Subject: Assessment, Evaluation, and Treatment Planning (3 credits, non-liberal, introductory)

This essay should be 3-5 pages, and it should be written as if it were me speaking. And it should include Assessment, evaluation, and treatment planning, regarding clients in a substance abuse treatment program. This essay doesn’t need references because its suppose to sound as if it’s coming from me, and my experience. Please organize this essay well. You can also include in the Essay:

Assessment: The procedures by which a counselor/program identifies and evaluates and individual’s strengths, weaknesses, problems and needs for the development of the treatment plan. (Please include when and how assessment takes place)

Evaluation: Please include how the clients are evaluated for example the clients go through a screening process. Screening process: The process by which a client is determined appropriate and eligible for admissions to a particular program.

Treatment planning: The process by which the counselor and the client identify and rank problems needing resolutions, establish long and short term goals, and decide on treatment methods and resources to be used. Please elaborate on all sections of this essay

And whatever else is best suited for Assessment, Evaluation, and Treatment Planning you may think is appropriate.

Please use this as a first paragraph to this essay:

I would like to obtain prior learning credits for having my CASAC T. The topic which I’m going to write about in this essay is entitled Assessment, evaluation, and treatment planning (3 credits, Non liberal, Introductory). In 2009 I attended outreach training institute located at 117-11 Myrtle Ave, Richmond Hill NY, 11418. Throughout the 11 month duration, I completed 350 hours training to obtain my CASAC T.  While attending the CASAC T training we explored many useful topics but the topic in which we are going to discuss is Assessment, evaluation and treatment planning. We also participated in many hands on activities, which will be beneficial while working in the field of substance abuse.

Code is complete but there is a bug when it compiles. Please fix the bug and then I will accept your bid. This is very urgent. I only have one hour!!

————————————————————————————————–

#ifndef CHESST01_H_INCLUDED
#define CHESST01_H_INCLUDED
 #include<string>
using namespace std;
class Piece
{
  private:
  string itsName;
  int itsVertAddress;
  int itsHorzAddress;

  public:
  void  setItsVertAddress (int address){itsVertAddress = address;}
  void  setItsHorzAddress (int address){itsHorzAddress = address;}
  int  getItsVertAddress()  {return itsVertAddress;}
  int  getItsHorzAddress()  {return itsHorzAddress;}
  void  setItsName  (string name){itsName=name;}
  string getItsName  ()  {return itsName;}
};

class Board
{
  private:
  string itsBoard[26];
  public:
  void setItsBoard(string []);
  void setPcsLoc(string,int,int);
  void DisplayBoard();
  bool emptySpot(int ,int );

};

///////////////////
// bool searchTouch(Piece [],int);
// bool searchMove(Piece [],int,int);
/////////////////////
void Board::setItsBoard(string arr[])
{
  for(int i=0;i<26;i++)
  itsBoard[i]=arr[i];
}
void Board::DisplayBoard()
{
  for(int i=0;i<26;i++)
  cout<<itsBoard[i]<<endl;;

}

void Board::setPcsLoc(string name,int horz,int vert)
{
  itsBoard[vert].replace(horz,2,name);
}

bool Board::emptySpot(int horz,int vert)
{
  cout<<“n”<<itsBoard[horz][vert]<<endl;
  if(itsBoard[horz][vert]==’.’)
  {

  return true;
  }
  return false;
}
/*
 bool searchTouch(Piece pieces[],int address) ////to check if the player is choosing the right Piece
 {
  bool ok_touch = false;
  int Horz = address%10;
  int Vert = address/10;
  for(int i=0;i<32;i++)

  if((pieces[i].getItsHorzAddress()==Horz)&&(pieces[i].getItsVertAddress()==Vert))
  return ok_touch;

  return ok_touch;
 }

 bool searchMove(Piece pieces[],int addtouch,int addmove) ////to check if the player is choosing the right Piece
 {
  bool ok_touch = false;
  int THorz = addtouch%10;
  int TVert = addtouch/10;
  int MHorz = addmove%10;
  int MVert = addmove/10;
  for(int i=0;i<32;i++)

  if((pieces[i].getItsHorzAddress()==THorz)&&(pieces[i].getItsVertAddress()==TVert))
  {
  pieces[i].setPcsLoc(pieces[i].getItsName(),MHorz,MVert);
  return ok_touch;
  }
  return ok_touch;
 }
  */
#endif // CHESST01_H_INCLUDED

  #include<iostream>
  #include<string>
  #include<cstdlib>
  #include”chess.h”
  bool touchMove(Board*,Piece [],int,int,bool);
  bool checkMove(int);
  bool emptySpot(Piece [],int , int);
  bool pieceMove(Piece [],string ,string ,int ,int );
  int switchNum(int,char);
  void resetBoard(Board *,Piece []);

  using namespace std;
  int main()
  {  /////  2  6  10  14  18  22  26  30
  string arrPcs[26]={“–1—2—3—4—5—6—7—8—“,
  “-  ####  ####  ####  ####-“,
  “1  ####  ####  ####  ####1”,//2
  “-  ####  ####  ####  ####-“,
  “-####  ####  ####  ####  -“,
  “2####  ####  ####  ####  2”,//5
  “-####  ####  ####  ####  -“,
  “-  ####  ####  ####  ####-“,
  “3  ####  ####  ####  ####3”,//8
  “-  ####  ####  ####  ####-“,
  “-####  ####  ####  ####  -“,
  “4####  ####  ####  ####  4”,//11
  “-####  ####  ####  ####  -“,
  “-  ####  ####  ####  ####-“,
  “5  ####  ####  ####  ####5”,//14
  “-  ####  ####  ####  ####-“,
  “-####  ####  ####  ####  -“,
  “6####  ####  ####  ####  6”,//17
  “-####  ####  ####  ####  -“,
  “-  ####  ####  ####  ####-“,
  “7  ####  ####  ####  ####7”,//20
  “-  ####  ####  ####  ####-“,
  “-####  ####  ####  ####  -“,
  “8####  ####  ####  ####  8”,//23
  “-####  ####  ####  ####  -“,
  “–1—2—3—4—5—6—7—8—“
  };
  Board gameBoard;
  gameBoard.setItsBoard(arrPcs );

  Piece pcs[64];

  resetBoard(&gameBoard,pcs);

  gameBoard.DisplayBoard();/////display the game board on screen
  cout<<“0 to end the game anytime”<<endl;
  cout<<“entry:2 digits each from 1-8.first: vertical count”<<endl;
  bool exit = false;
  bool white= true; //////the turn is for white
  cout<<“White Turn”<<endl;

while(exit==false)
{
int touch,move;
cout<<“Choose the piece you want to move!”<<endl;
cin>>touch;
if(touch!=0)
{
cout<<“CHoose the target location “<<endl;
cin>>move;
if((checkMove(move))&&(checkMove(touch))&&(touchMove(&gameBoard,pcs,touch,move,white)))
{
  gameBoard.DisplayBoard();/////display the game board on screen
  if(white)
  {
  white=false;/////switch player
  cout<<“Black Turn”<<endl;
  }
  else
  {
  white=true;
  cout<<“White Turn”<<endl;
  }
}
  else cout<<“not accepted”<<endl;
}
else
exit=true;
}

  return 0;
  }

 bool touchMove(Board *aboard,Piece pieces[],int addtouch,int addmove,bool white) ////
 {
  string nameT,nameM;
  bool ok_touch = false;
  int THorz = addtouch%10;
  int TVert = addtouch/10;
  int MHorz = addmove%10;
  int MVert = addmove/10;
  THorz=switchNum(THorz,’h’);
  MHorz=switchNum(MHorz,’h’);
  TVert=switchNum(TVert,’v’);
  MVert=switchNum(MVert,’v’);

for(int i=0;i<=64;i++)//searching for the touched piece
  if((pieces[i].getItsHorzAddress()==TVert)&&(pieces[i].getItsVertAddress()==THorz)&&(pieces[i].getItsName()!=”  “))
  {
  nameT=pieces[i].getItsName();
  if((white)&&(nameT[0]==’W’)) ////white can move white only
  {
  for(int k=0;k<=64;k++)////searching for the target
  if((pieces[k].getItsHorzAddress()==MVert)&&(pieces[k].getItsVertAddress()==MHorz))
  {
  nameM=pieces[k].getItsName();
  if((white)&&(nameM[0]!=’W’))
  {
  if(pieceMove(pieces,nameT,nameM,addtouch,addmove))////////////fuction for the rules of each piece movement
  {
  pieces[k].setItsName(pieces[i].getItsName());
  aboard->setPcsLoc(pieces[k].getItsName(),MHorz,MVert);

 pieces[i].setItsName(”  “);
 aboard->setPcsLoc(pieces[i].getItsName(),THorz,TVert);
  ok_touch=true;
  }///////////////////////////////////////////////////
  }
  }
  }
  else if
  ((!white)&&(nameT[0]==’B’)) ////black can move black only
  {
  for(int k=0;k<=64;k++) ///////searching for the touched piece
  if((pieces[k].getItsHorzAddress()==MVert)&&(pieces[k].getItsVertAddress()==MHorz))
  {
  nameM=pieces[k].getItsName();
  if((!white)&&(nameM[0]!=’B’))
  {
  ///////////////////////////////////////////////////
  if(pieceMove(pieces,nameT,nameM,addtouch,addmove))////////////fuction for the rules of each piece movement
  {
  pieces[k].setItsName(pieces[i].getItsName());
  aboard->setPcsLoc(pieces[k].getItsName(),MHorz,MVert);

 pieces[i].setItsName(”  “);
 aboard->setPcsLoc(pieces[i].getItsName(),THorz,TVert);
  ok_touch=true;
  }
  //////////////////////////////////////////////////////////
  }
  }
  }
  else ok_touch=false;
  }
  return ok_touch;
 }

  int switchNum(int num,char xChar)
  {
  if(xChar==’h’)
  switch(num)
  {
  case 1 : num =2;
  break;
  case 2 : num =6;
  break;
  case 3 : num =10;
  break;
  case 4 : num =14;
  break;
  case 5 : num =18;
  break;
  case 6 : num =22;
  break;
  case 7 : num =26;
  break;
  case 8 : num =30;
  break;
  default :
  break;
  }
  else
  switch(num)
  {
  case 1 : num =2;
  break;
  case 2 : num =5;
  break;
  case 3 : num =8;
  break;
  case 4 : num =11;
  break;
  case 5 : num =14;
  break;
  case 6 : num =17;
  break;
  case 7 : num =20;
  break;
  case 8 : num =23;
  break;
  default :
  break;
  }
  return num;

  }

  void resetBoard(Board *gameBoard,Piece pcs[])
  {

  for(int i=0,j=2;i<8;i++)
  {
  pcs[i].setItsName(“WP”);
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(5);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,5);
  j+=4;
  }

  for(int i=8,j=2;i<16;i++)
  {
  pcs[i].setItsName(“BP”);
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(20);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,20);
  j+=4;
  }
/////set rook locations
  for(int i=16,j=2;i<18;i++)
  {
  //////set location for white rook
  pcs[i].setItsName(“WR”);
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,2);

  ////set location for black rook
  pcs[i+2].setItsName(“BR”);
  pcs[i+2].setItsVertAddress(j);
  pcs[i+2].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[i+2].getItsName(),j,23);
  j=30;

  }

  /////set Knight locations
  for(int i=20,j=6;i<22;i++)
  {
  //////set location for white knight
  pcs[i].setItsName(“WN”);
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,2);

  ////set location for black knight
  pcs[i+2].setItsName(“BN”);
  pcs[i+2].setItsVertAddress(j);
  pcs[i+2].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[i+2].getItsName(),j,23);
  j=26;
  }

  /////set Bishops locations
  for(int i=24,j=10;i<26;i++)
  {
  //////set location for white bishop
  pcs[i].setItsName(“WB”);
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,2);

  ////set location for black bishop
  pcs[i+2].setItsName(“BB”);
  pcs[i+2].setItsVertAddress(j);
  pcs[i+2].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[i+2].getItsName(),j,23);
  j=22;
  }

  /////set Queens locations
  //////set location for white queen
  pcs[28].setItsName(“WQ”);
  pcs[28].setItsVertAddress(14);
  pcs[28].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[28].getItsName(),14,2);

  ////set location for black queen
  pcs[29].setItsName(“BQ”);
  pcs[29].setItsVertAddress(14);
  pcs[29].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[29].getItsName(),14,23);

 /////set kings locations
  //////set location for white king
  pcs[30].setItsName(“WK”);
  pcs[30].setItsVertAddress(18);
  pcs[30].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[30].getItsName(),18,2);

  ////set location for black king
  pcs[31].setItsName(“BK”);
  pcs[31].setItsVertAddress(18);
  pcs[31].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[31].getItsName(),18,23);

/////////////set the other spots
int k=8;
  for(int i=32,j=2;i<64;i++)
  {
  //////set location for white knight
  pcs[i].setItsName(”  “);
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(k);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,k);
if(j<30)
j+=4;
else
{
j=2;
k+=3;
}
  }
  }

bool checkMove(int move)
{
  int first  = move/10;
  int second = move%10;
  if((first<1)||(first>8)||(second<1)||(second>8))
  return false;
  return true;
}

bool pieceMove(Piece pieces[],string nameT,string nameM,int touch ,int move )
{
  int moving=touch;
  int THorz = touch%10;
  int TVert = touch/10;
  int MHorz = move%10;
  int MVert = move/10;
  int movingH=THorz;
  int movingV=TVert;
  int diff=abs(touch-move);
  int signedDiff=touch-move;

  if(nameT[1]==’P’) ////if its  pawn
  {
  if(nameT[0]==’W’)//////white pawn
  {
  if(nameM[0]==’ ‘)//////////////piece not attacking
  {
  if(move==touch+10)////one step forward ?
  return true;//yes? go
  return false;//no ? not accepted
  }
  else if(nameM[0]!=’ ‘)////attacking abviously black piece
  if((move==touch+11)||(move==touch+9)) //moving diagonal down?
  return true; /////diagonal
  return false;/////not diagonal
  }
  if(nameT[0]==’B’)//////black pawn
  {
  if(nameM[0]==’ ‘)//////////////piece not attacking
  {
  if(move==touch-10)////one step up
  return true;/////up ok
  return false;/////not up not accepted
  }
  if(nameM[0]!=’.’)////attacking abviously white piece
  if((move==touch-11)||(move==touch-9)) ////diagonal up
  return true;/////ok move
  return false;////not accepted
  }
  return false;////any unexpected mistake will return a non accepted move
  }///////////////////////////////////////////////////////////////////end of pawn statment
  ////////////knight
  if(nameT[1]==’N’)
  {
  int Hdiff=abs(THorz-MHorz);
  int Vdiff=abs(TVert-MVert);
  cout<<“Hdiff  and Vdiff are “<<Hdiff<<”  “<<Vdiff<<endl;
  if(((Hdiff==1)&&(Vdiff==2))||((Hdiff==2)&&(Vdiff==1)))
  return true;
  return false;
  }
  ////////////////////////////////////////////////////////////////////end night statement
  if(nameT[1]==’K’)
  {
  if((diff==1)||(diff==11)||(diff==9)||(diff==10))////one step any direction
  return true; /////good move
  return false;////not accepted
  //////king
  }

  else if(nameT[1]==’R’)
  {
  if((movingH==MHorz)||(movingV==MVert)) ////if its vertical or horizontal moving rook or queen
  {
  ////while loop to the check that there are no objects to block the moving objects’s way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if(movingH>MHorz)//theobjects is moving to the left
  movingH–;
  if(movingH<MHorz)////right direction
  movingH++;
  if(movingV>MVert)//theobjects is moving Down
  movingV–;
  if(movingV<MVert)////Up direction
  movingV++;
  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object
  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,’h’),switchNum(movingV,’v’)))
  return false; ////if an object is found the movement cant be done

  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  else return false;
  }

  /////////different selection
  if(nameT[1]==’B’)
  {
  if((diff%9==0)||(diff%11==0)) ////if its diagonal moving bishop or queen
  {
  ////while loop to the check that there are no objects to block the moving objects’s way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if((MHorz>THorz)&&(MVert>TVert))//theobjects is moving to the left
  {
  movingH++;
  movingV++;
  }
  if((MHorz<THorz)&&(MVert<TVert))////right direction
  {
  movingH–;
  movingV–;
  }
  if((MHorz>THorz)&&(MVert<TVert))////right direction
  {
  movingH++;
  movingV–;
  }
  if((MHorz<THorz)&&(MVert>TVert))////right direction
  {
  movingH–;
  movingV++;
  }
  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object
  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,’h’),switchNum(movingV,’v’)))
  return false; ////if an object is found the movement cant be done
  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  else return false;
  }
  if(nameT[1]==’Q’)
  {
  if((movingH==MHorz)||(movingV==MVert)) ////if its vertical or horizontal moving rook or queen
  {
  ////while loop to the check that there are no objects to block the moving objects’s way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if(movingH>MHorz)//theobjects is moving to the left
  movingH–;
  if(movingH<MHorz)////right direction
  movingH++;
  if(movingV>MVert)//theobjects is moving Down
  movingV–;
  if(movingV<MVert)////Up direction
  movingV++;
  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object
  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,’h’),switchNum(movingV,’v’)))
  return false; ////if an object is found the movement cant be done
  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  if((diff%9==0)||(diff%11==0)) ////if its diagonal moving bishop or queen
  {
  ////while loop to the check that there are no objects to block the moving objects’s way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if((MHorz>THorz)&&(MVert>TVert))//theobjects is moving to the left
  {
  movingH++;
  movingV++;
  }
  if((MHorz<THorz)&&(MVert<TVert))////right direction
  {
  movingH–;
  movingV–;
  }
  if((MHorz>THorz)&&(MVert<TVert))////right direction
  {
  movingH++;
  movingV–;
  }
  if((MHorz<THorz)&&(MVert>TVert))////right direction
  {
  movingH–;
  movingV++;
  }

  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object

  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,’h’),switchNum(movingV,’v’)))
  return false; ////if an object is found the movement cant be done

  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  }
return false;
}

bool emptySpot(Piece pieces[],int h, int v)
{
  for(int i=0;i<=64;i++)
  if((pieces[i].getItsHorzAddress()==v)&&(pieces[i].getItsVertAddress()==h)&&(pieces[i].getItsName()==”  “))
  return true;
  return false;
}