glDrawElements crashs.

I'm trying to draw a simple model with open gl es on iOS 9.

And due to some unkown reason it always crash for EXC_BAD_ACCESS(code=1) problem.

The address it's trying to access is the very address of indices[0].

What am I doing wrong ?😝

import GLKit
// A simple model object. Note: gl program and shaders are correctly created and attached.
public class AMModelObject: NSObject {
    // when been set buffers would be updated
    public var vertexData: [AMVertex]? {
        willSet {
            __deleteBuffers()
        }
        didSet {
            __updateBuffers()
        }
    }
    // when been set buffers would be updated
    public var indices: [UInt16]? {
        willSet {
            __deleteBuffers()
        }
        didSet {
            __updateBuffers()
        }
    }
    // the vertex buffer handler
    private var __vertexBufferHandler: GLuint = 0
    // the index buffer handler
    private var __indexBufferHandler: GLuint = 0
    // remove all existed buffers.
    private func __deleteBuffers() {
        if __vertexBufferHandler != 0 {
            glDeleteBuffers(1, &__vertexBufferHandler)
        }
        if __indexBufferHandler != 0 {
            glDeleteBuffers(1, &__indexBufferHandler)
        }
    }
    // to update buffers
    private func __updateBuffers() {
        guard var vertexData = vertexData else { return }

     
        glGenBuffers(1, &__vertexBufferHandler)
        glBindBuffer(UInt32(GL_ARRAY_BUFFER), __vertexBufferHandler)
        withUnsafePointer(&vertexData[0]) {
            glBufferData(UInt32(GL_ARRAY_BUFFER), sizeof(AMVertex) * vertexData.count, $0, UInt32(GL_STATIC_DRAW))
        }
    
        guard var indices = indices else { return }
        glGenBuffers(1, &__indexBufferHandler)
        glBindBuffer(UInt32(GL_ELEMENT_ARRAY_BUFFER), __indexBufferHandler);
        withUnsafePointer(&indices[0]) {
            glBufferData(UInt32(GL_ELEMENT_ARRAY_BUFFER), indices.count * sizeof(UInt16), $0, UInt32(GL_STATIC_DRAW))
        }
    }
   // to render the object.
    public func render() {
        guard var vertexData = vertexData else { return }
    
        glBindBuffer(UInt32(GL_ARRAY_BUFFER), __vertexBufferHandler)
        defer { glBindBuffer(UInt32(GL_ARRAY_BUFFER), 0) }
        glEnableVertexAttribArray(UInt32(GLKVertexAttrib.Position.rawValue))
        /
        defer { glDisableVertexAttribArray(UInt32(GLKVertexAttrib.Position.rawValue)) }
        withUnsafePointer(&vertexData[0].pos) {
            let pointer = $0
            glVertexAttribPointer(UInt32(GLKVertexAttrib.Position.rawValue), 
                4,                                                           
                UInt32(GL_FLOAT),                                            
                UInt8(GL_FALSE),
                Int32(sizeof(AMVertex)),                                     
                pointer)                                                     
        }
        // render when has indices. If no index exists, render with glDrawArrays
        if let indices = indices {
            glBindBuffer(UInt32(GL_ELEMENT_ARRAY_BUFFER), __indexBufferHandler)
            defer{ glBindBuffer(UInt32(GL_ELEMENT_ARRAY_BUFFER), 0) }
            indices.withUnsafeBufferPointer {
// Crash Here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                glDrawElements(UInt32(GL_TRIANGLES),                         
                    Int32(indices.count / 3),                                
                    UInt32(GL_UNSIGNED_SHORT),                               
                    $0.baseAddress)                                          
            }
        } else {
// Crash Here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            glDrawArrays(UInt32(GL_TRIANGLES),
                         0,
                         Int32(vertexData.count))
        }
    }
}