Marching Cubes generating holes in mesh

Question

I'm working on a Marching Cubes implementation in Unity. My code is based on Paul Bourke's code actually with a lot of modifications, but anyway I'm checking if a block at a position is null if it is than a debug texture will be placed on it.

This is my MC script.

    public class MarchingCubes
{
private World world;
private Chunk chunk;
private List<Vector3> vertices = new List<Vector3> ();
private List<Vector3> normals = new List<Vector3> ();
private Vector3[] ns;
private List<int> triangles = new List<int> ();
private List<Vector2> uvs = new List<Vector2> ();
private Vector3[] positions = new Vector3[8];
private float[] corners = new float[8];
private Vector3i size = new Vector3i (16, 128, 16);

Vector3[] vertlist = new Vector3[12];

private float isolevel = 1f;

private float Corner (Vector3i pos)
{
    int x = pos.x;
    int y = pos.y;
    int z = pos.z;
    if (x < size.x && z < size.z) {
        return chunk.GetValue (x, y, z);
    } else {
        int ix = chunk.X, iz = chunk.Z;
        int rx = chunk.region.x, rz = chunk.region.z;
        if (x >= size.x) {
            ix++;
            x = 0;
        }

        if (z >= size.z) {
            iz++;
            z = 0;
        }
        return chunk.region.GetChunk (ix, iz).GetValue (x, y, z);
    }
}

Block block;

public Mesh MarchChunk (World world, Chunk chunk, Mesh mesh)
{
    this.world = world;
    this.chunk = chunk;

    vertices.Clear ();
    triangles.Clear ();
    uvs.Clear ();

    for (int x = 0; x < size.x; x++) {
        for (int y = 1; y < size.y - 2; y++) {
            for (int z = 0; z < size.z; z++) {

                block = chunk.GetBlock (x, y, z);
                int cubeIndex = 0;

                for (int i = 0; i < corners.Length; i++) {
                    corners [i] = Corner (new Vector3i (x, y, z) + offset [i]);
                    positions [i] = (new Vector3i (x, y, z) + offset [i]).ToVector3 ();

                    if (corners [i] < isolevel)
                        cubeIndex |= (1 << i);
                }

                if (eTable [cubeIndex] == 0)
                    continue;

                for (int i = 0; i < vertlist.Length; i++) {
                    if ((eTable [cubeIndex] & 1 << i) == 1 << i)
                        vertlist [i] = LinearInt (positions [eCons [i, 0]], positions [eCons [i, 1]], corners [eCons [i, 0]], corners [eCons [i, 1]]);
                }

                for (int i = 0; triTable [cubeIndex, i] != -1; i += 3) {
                    int index = vertices.Count;

                    vertices.Add (vertlist [triTable [cubeIndex, i]]);
                    vertices.Add (vertlist [triTable [cubeIndex, i + 1]]);
                    vertices.Add (vertlist [triTable [cubeIndex, i + 2]]);

                    float tec = (0.125f);
                    Vector2 uvBase = block != null ? block.UV : new Vector2 ();

                    uvs.Add (uvBase);
                    uvs.Add (uvBase + new Vector2 (0, tec));
                    uvs.Add (uvBase + new Vector2 (tec, tec));
                                    
                    triangles.Add (index + 0);
                    triangles.Add (index + 1);
                    triangles.Add (index + 2);
                }
            }
        }
    }       

    if (mesh == null)
        mesh = new Mesh ();
    mesh.Clear ();
    mesh.vertices = vertices.ToArray ();
    mesh.triangles = triangles.ToArray ();
    mesh.uv = uvs.ToArray ();
    mesh.RecalculateNormals ();
    return mesh;
}

bool IsBitSet (int b, int pos)
{
    return ((b & pos) == pos);
}

Vector3 LinearInt (Vector3 p1, Vector3 p2, float v1, float v2)
{
    Vector3 p;
    p.x = p1.x + (isolevel - v1) * (p2.x - p1.x) / (v2 - v1);
    p.y = p1.y + (isolevel - v1) * (p2.y - p1.y) / (v2 - v1);
    p.z = p1.z + (isolevel - v1) * (p2.z - p1.z) / (v2 - v1);
    return p;
}

private static int[,] eCons = new int[12, 2] {
    { 0, 1 },
    { 1, 2 },
    { 2, 3 },
    { 3, 0 },
    { 4, 5 },
    { 5, 6 },
    { 6, 7 },
    { 7, 4 },
    { 0, 4 },
    { 1, 5 },
    { 2, 6 },
    { 3, 7 }
};

private static Vector3i[] offset = new Vector3i[8] {
    new Vector3i (0, 0, 1),
    new Vector3i (1, 0, 1),
    new Vector3i (1, 0, 0),
    new Vector3i (0, 0, 0),
    new Vector3i (0, 1, 1),
    new Vector3i (1, 1, 1),
    new Vector3i (1, 1, 0),
    new Vector3i (0, 1, 0)
};
  }

I didn't put the tables in the sample, because they are the same as the ones in Bourke's code.

EDIT: What I figured out yet is that the cell's value at the blue triangles is 0 so they don't have to be triangulated, but the cell's value under them is 1 and because of this a top triangle is created to complete the mesh.