Sewing up two meshes

Good afternoon! I'm trying to sew up two meshes. I do this as follows: first I convert the sprite into a mesh, then I duplicate the resulting mesh, shift it along the "z" axis, invert it, and then sew it up. But I faced such a problem: he sews rectangular meshes well, but in circular meshes there are some defects on the sides. So, how can you sew up these sides? (Materials and code)

public class ConvertSpriteInMesh : MonoBehaviour
{
    public Sprite sprite;
    private MeshDraft meshDraft = new MeshDraft();
    private Mesh mesh;
    void Start()
    {
        GetComponent<MeshFilter>().mesh = SpriteToMesh(sprite);
        SewingUp();
    }
    
    /// <summary>
    /// Sewing up nets
    /// </summary>
    private void SewingUp()
    {
        mesh = GetComponent<MeshFilter>().mesh;
        meshDraft = new MeshDraft(mesh);
        int leftVertical = mesh.vertices.Length / 2; // getting the beginning of the left vertical of the mesh
        int index = mesh.vertices.Length;
        
        for (int i = 0; i < leftVertical - 1; i++)
        {
            meshDraft.AddQuad(mesh.vertices[i], mesh.vertices[i+1], mesh.vertices[i + leftVertical + 1],mesh.vertices[i+leftVertical], 
                index);
            index += 4;
        }

        GetComponent<MeshFilter>().mesh = meshDraft.ToMesh(); // assign the resulting mesh
    }
    
    /// <summary>
    /// Convert Sprite to Mesh
    /// </summary>
    /// <param name="_sprite"></param>
    /// <returns></returns>
    private Mesh SpriteToMesh(Sprite _sprite)
    {
        // declaring variables
        Mesh mesh = new Mesh();
        Vector3[] _verticles;
        int[] _triangle;
        
        // assigning values
        _verticles = Array.ConvertAll(_sprite.vertices, i => (Vector3)i);
        _triangle = Array.ConvertAll(_sprite.triangles, i => (int)i);
        
        // changing the size of the array
        Array.Resize(ref _verticles, _verticles.Length * 2);
        Array.Resize(ref _triangle, _triangle.Length * 2);
        
        // adding another side
        for (int i = 0; i < _verticles.Length / 2; i++)
        {
            _verticles[_verticles.Length / 2 + i] = new Vector3(_verticles[i].x, _verticles[i].y, 0.5f);
        }
        for (int i = 0; i < _triangle.Length / 2; i++)
        {
            _triangle[_triangle.Length / 2 + i] = _triangle[i] + (_verticles.Length / 2);
        }
        
        // invert the second side
        for(int i = _triangle.Length / 2; i < _triangle.Length; i += 3) {
            var temp = _triangle[i];
            _triangle[i] = _triangle[i + 1];
            _triangle[i + 1] = temp;
        }

        // assigning the mesh
        mesh.vertices = _verticles;
        mesh.triangles = _triangle;

        mesh.RecalculateBounds();
        mesh.RecalculateNormals();
 
        return mesh;
    }
}

public partial class MeshDraft {
    public string name = "";
    public List<Vector3> vertices = new List<Vector3>();
    public List<int> triangles = new List<int>();
    public List<Vector3> normals = new List<Vector3>();
    public List<Vector4> tangents = new List<Vector4>();
    public List<Vector2> uv = new List<Vector2>();
    public List<Vector2> uv2 = new List<Vector2>();
    public List<Vector2> uv3 = new List<Vector2>();
    public List<Vector2> uv4 = new List<Vector2>();
    public List<Color> colors = new List<Color>();

    public MeshDraft(Mesh mesh) {
        name = mesh.name;
        vertices.AddRange(mesh.vertices);
        triangles.AddRange(mesh.triangles);
        normals.AddRange(mesh.normals);
        tangents.AddRange(mesh.tangents);
        uv.AddRange(mesh.uv);
        uv2.AddRange(mesh.uv2);
        uv3.AddRange(mesh.uv3);
        uv4.AddRange(mesh.uv4);
        colors.AddRange(mesh.colors);
    }
    public void AddQuad(Vector3 v0, Vector3 v1, Vector3 v2, Vector3 v3, int index, Color color = default(Color)) {
    vertices.Add(v0);
    vertices.Add(v1);
    vertices.Add(v2);
    vertices.Add(v3);

    Vector3 normal0 = Vector3.Cross(v2 - v1, v3 - v1).normalized;
    Vector3 normal1 = Vector3.Cross(v1 - v0, v2 - v0).normalized;

    normals.Add(normal0);
    normals.Add(normal0);
    normals.Add(normal1);
    normals.Add(normal1);

    colors.Add(color);
    colors.Add(color);
    colors.Add(color);
    colors.Add(color);

    triangles.Add(index);
    triangles.Add(index + 1);
    triangles.Add(index + 2);
    triangles.Add(index);
    triangles.Add(index + 2);
    triangles.Add(index + 3);
}
    public Mesh ToMesh() {
    var mesh = new Mesh { name = name };
    mesh.SetVertices(vertices);
    mesh.SetTriangles(triangles, 0);
    mesh.SetNormals(normals);
    mesh.SetTangents(tangents);
    mesh.SetUVs(0, uv);
    mesh.SetUVs(1, uv2);
    mesh.SetUVs(2, uv3);
    mesh.SetUVs(3, uv4);
    mesh.SetColors(colors);
    return mesh;
}

Successful stitching (screen)

Bad stitching (screen)