Transform not allowing direction?

I have instantiated a cave system, when the object spawns in, it always spawns at 0,0,0. Am I doing something wrong?

Here is the code I have : using UnityEngine; using System.Collections; using System;

 public class CC : MonoBehaviour
 {
 
     public GameObject holder;
 
     public int width;
     public int height;
 
     public GameObject wallSprite;
 
     public string seed;
     public bool useRandomSeed;
 
     [Range(0, 100)]
     public int randomFillPercent;
 
     int[,] map;
 
     void Start()
     {
         GenerateMap();
     }
 
     void Update()
     {
         if (Input.GetMouseButtonDown(0))
         {
             GenerateMap();
         }
     }
 
     void GenerateMap()
     {
         map = new int[width, height];
         RandomFillMap();
         for (int i = 0; i < 10; i++)
         {
             SmoothMap();
         }
         CreateSpriteMap(map);
     }
 
 
     void RandomFillMap()
     {
         if (useRandomSeed)
         {
             seed = Time.time.ToString();
         }
 
         System.Random pseudoRandom = new System.Random(seed.GetHashCode());
 
         for (int x = 0; x < width; x++)
         {
             for (int y = 0; y < height; y++)
             {
                 if (x == 0 || x == width - 1 || y == 0 || y == height - 1)
                 {
                     map[x, y] = 1;
                 }
                 else
                 {
                     map[x, y] = (pseudoRandom.Next(0, 100) < randomFillPercent) ? 1 : 0;
                 }
             }
         }
     }
 
     void SmoothMap()
     {
         for (int x = 0; x < width; x++)
         {
             for (int y = 0; y < height; y++)
             {
                 int neighbourWallSprite = GetSurroundingWallCount(x, y);
 
                 if (neighbourWallSprite > 4)
                     map[x, y] = 1;
                 else if (neighbourWallSprite < 4)
                     map[x, y] = 0;
 
             }
         }
     }
 
     int GetSurroundingWallCount(int gridX, int gridY)
     {
         int wallCount = 0;
         for (int neighbourX = gridX - 1; neighbourX <= gridX + 1; neighbourX++)
         {
             for (int neighbourY = gridY - 1; neighbourY <= gridY + 1; neighbourY++)
             {
                 if (neighbourX >= 0 && neighbourX < width && neighbourY >= 0 && neighbourY < height)
                 {
                     if (neighbourX != gridX || neighbourY != gridY)
                     {
                         wallCount += map[neighbourX, neighbourY];
                     }
                 }
                 else
                 {
                     wallCount++;
                 }
             }
         }
 
         return wallCount;
     }
     Vector3 CoordToWorldPoint(Coord wallSprite)
     {
         return new Vector3(-width / 2 + .5f + wallSprite.wallSpriteX, 2, -height / 2 + .5f + wallSprite.wallSpriteY);
     }
     struct Coord
     {
         public int wallSpriteX;
         public int wallSpriteY;
 
         public Coord(int x, int y)
         {
             wallSpriteX = x;
             wallSpriteY = y;
         }
     }
 
     void CreateSpriteMap(int[,] borderedMap)
     {
         if (GameObject.Find("Map2D"))
         {
             Destroy(GameObject.Find("Map2D"));
         }
 
         for (int x = 0; x < borderedMap.GetLength(0); x++)
         {
             for (int y = 0; y < borderedMap.GetLength(1); y++)
             {
                 if (borderedMap[x, y] == 1)
                 {
                     Vector3 pos3D = CoordToWorldPoint(new Coord(x, y));
                     Vector3 pos2D = new Vector3(pos3D.x, pos3D.z, 0);
                     GameObject newWallSprite = Instantiate(wallSprite, pos2D, Quaternion.identity) as GameObject;
                     newWallSprite.transform.parent = holder.transform;
                 }
             }
         }
     }
 }