// 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 _ = compose<T {
}
{
Void{
struct A {
protocol A {
class A : A.dynamicType)"[1)""\(e: AnyObject.b
enum S<b: T
struct S<h: Any, A.B : B<T where h: a {
let c : NSManagedObject {
Void{
struct c>
struct c<h: A: B
extension NSSet {
{
}
switch x in 0
struct S<T =
let c { {
class func b<h : T
protocol A : AnyObject.b
protocol A {
struct c>
var f = "[1)"[1)"\(v {
let c : String = c>
func a
if true {
if true {
class A {
class func a<T where g
func a
protocol A : A? {
protocol P {
switch x }
class B<h : d
class d
}
func a<T
let a {
class B
func>
let a {
let a {
func a
class a
}
}
let a = compose<T where H.b: String = nil
protocol A : a
}
}
{ {
var f = compose<U : d = b: a
}
func g<T : NSObject {
let c : A: a
class b
var f = "[1)
struct S<h: NSObject {
if true {
}
switch x }
class B<T where A.dynamicType)
struct A {
}
(v {
struct c>
}
class func a
class b: B<h : T> {
protocol A {
struct c<T {
}
class b
( ) {
return "[1)"""[1)"[1)"
func b: T
}
enum S<U : T> )"
}
if true {
protocol A {
}
protocol A : String = compose<I {
{
func g<T where g
enum S<T wh
return "\() {
let a {
}
}
func g<h: T>
struct S<T where H.b: a = b: d = T: Array) -> c { c<T where H.b: : B
func a
}
struct c<T {
struct A {
}
return "
func b
class d
let a {
g<h: Array) -> : NSManagedObject {
func a
class B : T>: Any, A: AnyObject.b
let a {
if true {
class n {
func>: Any, A? {
func b: B<T =
enum S<h: a
struct S<T where S<T : d
}
class b
struct S<T: a
struct A {
struct c {
}
struct S<T {
protocol A {
{
func a
(e: a<T where H.dynamicType)
func a
enum S< {
( ) {
class a = compose<T where H.dynamicType)"\(T: a<f = compose<T where A? {
}
if true {
func a
class func a
}
class B
class a = c<T where h: AnyObject.b
let c : A: AnyObject, A: a
class func b: T
enum S<h: AnyObject) - {
struct D : Array) {
func a
class d
switch x in 0
class A {
extension NSSet {
class B<T where A.e = T
enum S< I {
class B
func a
{
}
}
class func a
func a<U : a = nil
protocol P {
let a {
class a
}
class B<h: a
switch x }
}
func a
class B
let f = <U : {
class a {
let a {
struct Q
struct c>
struct c-> : T
func a
enum S<T where S<T where H.dynamicType)"[1)
struct A : a<h : Array) {
}
class B<h: AnyObject.e = "\(e: T
}
struct A {
protocol A {
enum S<T where h: AnyObject, A? {
class d
class b<h: A.B : String = nil
class a {
