//  The converted code is limited to 4 KB.
//  Upgrade your plan to remove this limitation.
//
//  Converted to Swift 4 by Swiftify v4.1.6738 - https://objectivec2swift.com/
var System: using?
var `set`: `private`?
var `set`: `private`?
var `set`: `private`?
var TraceEvent: `public` event TraceEventHandler?
var: `private` `set`?
var `set`: `private`?
var `set`: `private`?
var: `private` `set`?
var `set`: `private`?
var `set`: `private`?
var `set`: `private`?
var RunningThreads: `private` Stack = new
private var byte = [`public`](repeating: , count: )
var run = false
var `private`: `private` int numThreads?

func TraceEventHandler(sender: object, e: TraceEventArgs) -> `public` delegate void {
}

func Stack() {
}

func (IPAddress(address) -> `public` void PingHost {
    Thread
    pingRunThread = new
    Thread(PingRun)
    RunningThreads.push(pingRunThread)
    pingRunThread.start(new, TracePingRun, (, this, address)
}

func RouteEntry() -> `public` {
    BestRoundTrip = Int64.maxValue
    WorstRoundTrip = 0
}

func TraceEventArgs(traceEventType: TraceEventType) -> `public` {
    TraceEventType = traceEventType
}

func TracePingRun(trace: Trace, address: IPAddress) -> `public` {
    Trace = trace
    Address = address
}

func Trace() -> `private` {
}

func (IPAddress(address, int pingTimeout, bool: int pingTimeFrame) -> `public` Trace {
    resolveNames
    var: int pingSize
    let maxHops: int pingSize
    do {
        Address = address
        PingTimeout = pingTimeout
        PingTimeFrame = pingTimeFrame
        Route = new
    }
}

func MakeByteArray(int length) {
    byte
    byteData = new
    byte[length]
    for i in 0..<byteData.length {
        byteData[i] = 0x65
    }
    return byteData
}

func Start() -> `public` void {
    run = true
    new
    Thread(TraceRun).start(this)
}

func Stop() -> `public` void {
    run = false
}

func (TraceEventType(tet) -> `public` void OnTraceEvent {
    if TraceEvent != null {
        TraceEvent(this, new, TraceEventArgs, (, tet)
    }
}

/// <summary>
///
/// </summary>
/// <param name="data"></param>
private func (object(data) -> `public` void TraceRun {
    if    {

    }
     as? data `is` Trace
    return
    let trace = data as? Trace
    byte
    byteData = MakeByteArray(trace?.pingSize)
    PingOptions
    pingOptions = new
    PingOptions(1, false)
    Ping
    ping = new
    Ping()
    var run = true
    let lastTtl: Int = 1
    while run && trace?.run != nil && lastTtl <= trace?.maxHops ?? 0 {
        pingOptions = new
        PingOptions(lastTtl, false)
        let pingReply: PingReply = ping.send(trace?.address, trace?.pingTimeout, byteData, pingOptions)
        if pingReply.address != null {
            run = !pingReply.address.equals(trace?.address)
            lock(trace?.route)
            do {
                if null == trace?.route.find(delegate, (, RouteEntry, re_) {
                    return re_.address.toString() == pingReply.address.toString()
                }
                do {
                    RouteEntry
                    re = new
                    RouteEntry()
                    re.address = pingReply.address
                    re.isNull = false
                    re.ttl = lastTtl
                    trace?.route.add(re)
                }
                //t.OnTraceEvent(TraceEventType.PingSend);
            }
            trace?.pingHost(pingReply.address)
            Thread.sleep(1)
            lastTtl += 1
        } else {
            if pingReply.status == IPStatus.timedOut {
                lastTtl += 1
                lock(trace?.route)
                do {
                    //if (!trace.Route.ContainsKey(trace.Address))
                    if trace?.route.count ?? 0 < lastTtl {
                        RouteEntry
                        re = new
                        RouteEntry()
                        re.loss = 1
                        re.text = "N/A"
                        re.address = IPAddress.any
                        re.ttl = lastTtl - 1
                        re.isNull = true
                        trace?.route.add(re)
//  %< ------------------------ The converted code is limited to 4 KB ------------------------ %<