// Distributed under the terms of the MIT license
// Test case submitted to project by https://github.com/practicalswift (practicalswift)
// Test case found by fuzzing

{
var d : A> () {
}
let d
typealias d>() in a {
func c)
typealias d = b: NSManagedObject {
}
}
}
if true }
class A<d where B : H.c(n: A, Bool) {
}
}
var b(n: I) -> Any, e: SequenceType, k : C {
}
}
typealias e == nil
typealias d
func g<T>?
class B : [(() {
return g: H.Type) -> {
}
func f(() {
case C()
var b, i : (b> {
}
}
typealias F>, T : BooleanType))
var f = 1
}
typealias f : Any) -> () -> () {
}
var b = true {
import Foundation
let d>) { x = { self] = c>(2, U) -> {
}
deinit {
}
protocol a {
protocol a {
}
println(a
}
typealias g<T) { x in a {
println()
}
}
}
}
let c<T> : 1, range.f == 1))
return d
}
return S) {
import Foundation
class C> {
func a))-> (.b : b(h: (Any, V, y: Any) -> : BooleanType>() {
typealias B : T.Type
let d(v: $0) -> Int = B
}
}
func g(() {
protocol b {
}
let c: A>)
b
}
map() -> {
}
f(b, a)
}
struct c : d == [B
return z: NSManagedObject {
let v: P {
}
protocol b {
func f)
func f: NSManagedObject {
func a
import DummyModule
}
protocol c : X.c = .e = e?
func a: d {}
}
func i<b
}
if c = c<T where S.f == e? {
}
typealias e where T.advance(mx : l) {
}
let foo as String)
assert((s: Array) {
}
typealias f = h
}
}
}
}
()
}
public class b: (f: d where h>()(A> (A> T> Any {
struct c {
func e: C {
typealias E
}
let t: NSObject {
}
var b: S<T: SequenceType where T where d.Type
typealias F>) -> () -> {
}
func i> : b("ab"
let v: P> e() -> []
}
convenience init()
return ")(p: Any) {
}
A, let a: A.B(c, U) -> T) -> (c == {
class func c) -> {
}
}
protocol A : (s(Any, T])
typealias f = F
import Foundation
import CoreData
}
init<U) {
self.<Y> String {
}
typealias R
return NSData(b<T> [c<T) {
}
class c {
}
}
case C: A? {
t: B
protocol A {
})
protocol b where d.e : l.B = {
func e(","
class b
return ")(h
func a)
class A {
import Foundation
