Write data to mifare card with rc522 reader/writer

Hi everyone. I'm new with these tipe of programing.
I test some test sketch of rc522 reader/write.
I want to write data in to mifare card.
Mifare card 1k.
I want to write these example;
In sector 9 block 36 I want to write 11223344556677889900112233445566 with key A or key B a2a3a4a5a6a7.
Please if you cand me write an example of sketch to understand how to acces the card and how to write to it.
I know how to make the program in BASIC language, but I have some arduino uno board's and I want to use them in my security sistem at my home, and I don't want to make the acces only by ID, I want to have some data in to card and read these data to alow acces in my location.

Sorry for my bad eangles.

What’s wrong with the examples in the Arduino RFID Library for MFRC522? (Have a look at the ReadAndWrite.ino)

I try these code and I have one problem.
The key B is diferent from Key A.
I have read the information but I don’t write the new information.
“Authenticating again using key B…
PCD_Authenticate() failed: Error in communication.”

Were I need to put the key B to use the Key B to write the data?

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN         9           // Configurable, see typical pin layout above
#define SS_PIN          10          // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance.

MFRC522::MIFARE_Key key;

/**
* Initialize.
*/
void setup() {
   Serial.begin(9600); // Initialize serial communications with the PC
   while (!Serial);    // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
   SPI.begin();        // Init SPI bus
   mfrc522.PCD_Init(); // Init MFRC522 card

   // Prepare the key (used both as key A and as key B)
   // using FFFFFFFFFFFFh which is the default at chip delivery from the factory
   {
   key.keyByte[0] = 0x6c;
   key.keyByte[1] = 0x8f;
   key.keyByte[2] = 0x6f;
   key.keyByte[3] = 0xa1;
   key.keyByte[4] = 0x68;
   key.keyByte[5] = 0xef;
   }

   Serial.println(F("Scan a MIFARE Classic PICC to demonstrate read and write."));
   Serial.print(F("Using key (for A and B):"));
   dump_byte_array(key.keyByte, MFRC522::MF_KEY_SIZE);
   Serial.println();
   
   Serial.println(F("BEWARE: Data will be written to the PICC, in sector #1"));
}

/**
* Main loop.
*/
void loop() {
   // Look for new cards
   if ( ! mfrc522.PICC_IsNewCardPresent())
       return;

   // Select one of the cards
   if ( ! mfrc522.PICC_ReadCardSerial())
       return;

   // Show some details of the PICC (that is: the tag/card)
   Serial.print(F("Card UID:"));
   dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size);
   Serial.println();
   Serial.print(F("PICC type: "));
   MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
   Serial.println(mfrc522.PICC_GetTypeName(piccType));

   // Check for compatibility
   if (    piccType != MFRC522::PICC_TYPE_MIFARE_MINI
       &&  piccType != MFRC522::PICC_TYPE_MIFARE_1K
       &&  piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
       Serial.println(F("This sample only works with MIFARE Classic cards."));
       return;
   }

   // In this sample we use the second sector,
   // that is: sector #1, covering block #4 up to and including block #7
   byte sector         = 9;
   byte blockAddr      = 36;
   byte dataBlock[]    = {
       0x88, 0x13, 0x00, 0x00, //  1,  2,   3,  4,
       0x77, 0xec, 0xff, 0xff, //  5,  6,   7,  8,
       0x88, 0x13, 0x00, 0x09, //  9, 10, 255, 12,
       0x25, 0xda, 0x25, 0xda  // 13, 14,  15, 16
   };
   byte trailerBlock   = 39;
   MFRC522::StatusCode status;
   byte buffer[18];
   byte size = sizeof(buffer);

   // Authenticate using key A
   Serial.println(F("Authenticating using key A..."));
   status = (MFRC522::StatusCode) mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
   if (status != MFRC522::STATUS_OK) {
       Serial.print(F("PCD_Authenticate() failed: "));
       Serial.println(mfrc522.GetStatusCodeName(status));
       return;
   }

   // Show the whole sector as it currently is
   Serial.println(F("Current data in sector:"));
   mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
   Serial.println();

   // Read data from the block
   Serial.print(F("Reading data from block ")); Serial.print(blockAddr);
   Serial.println(F(" ..."));
   status = (MFRC522::StatusCode) mfrc522.MIFARE_Read(blockAddr, buffer, &size);
   if (status != MFRC522::STATUS_OK) {
       Serial.print(F("MIFARE_Read() failed: "));
       Serial.println(mfrc522.GetStatusCodeName(status));
   }
   Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":"));
   dump_byte_array(buffer, 16); Serial.println();
   Serial.println();

   // Authenticate using key B
   Serial.println(F("Authenticating again using key B..."));
   status = (MFRC522::StatusCode) mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_B, trailerBlock, &key, &(mfrc522.uid));
   if (status != MFRC522::STATUS_OK) {
       Serial.print(F("PCD_Authenticate() failed: "));
       Serial.println(mfrc522.GetStatusCodeName(status));
       return;
   }

   // Write data to the block
   Serial.print(F("Writing data into block ")); Serial.print(blockAddr);
   Serial.println(F(" ..."));
   dump_byte_array(dataBlock, 16); Serial.println();
   status = (MFRC522::StatusCode) mfrc522.MIFARE_Write(blockAddr, dataBlock, 16);
   if (status != MFRC522::STATUS_OK) {
       Serial.print(F("MIFARE_Write() failed: "));
       Serial.println(mfrc522.GetStatusCodeName(status));
   }
   Serial.println();

   // Read data from the block (again, should now be what we have written)
   Serial.print(F("Reading data from block ")); Serial.print(blockAddr);
   Serial.println(F(" ..."));
   status = (MFRC522::StatusCode) mfrc522.MIFARE_Read(blockAddr, buffer, &size);
   if (status != MFRC522::STATUS_OK) {
       Serial.print(F("MIFARE_Read() failed: "));
       Serial.println(mfrc522.GetStatusCodeName(status));
   }
   Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":"));
   dump_byte_array(buffer, 16); Serial.println();
       
   // Check that data in block is what we have written
   // by counting the number of bytes that are equal
   Serial.println(F("Checking result..."));
   byte count = 0;
   for (byte i = 0; i < 16; i++) {
       // Compare buffer (= what we've read) with dataBlock (= what we've written)
       if (buffer[i] == dataBlock[i])
           count++;
   }
   Serial.print(F("Number of bytes that match = ")); Serial.println(count);
   if (count == 16) {
       Serial.println(F("Success :-)"));
   } else {
       Serial.println(F("Failure, no match :-("));
       Serial.println(F("  perhaps the write didn't work properly..."));
   }
   Serial.println();
       
   // Dump the sector data
   Serial.println(F("Current data in sector:"));
   mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
   Serial.println();

   // Halt PICC
   mfrc522.PICC_HaltA();
   // Stop encryption on PCD
   mfrc522.PCD_StopCrypto1();
}

/**
* Helper routine to dump a byte array as hex values to Serial.
*/
void dump_byte_array(byte *buffer, byte bufferSize) {
   for (byte i = 0; i < bufferSize; i++) {
       Serial.print(buffer[i] < 0x10 ? " 0" : " ");
       Serial.print(buffer[i], HEX);
   }
}