Recursive generic depth=35

// Recursive generic type instantiation stress test
// Pushes MAX_INSTANTIATION_DEPTH and subtype checking limits

type LinkedList<T> = { value: T; next: LinkedList<T> | null };
type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
type DeepReadonly<T> = T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]> } : T;

type Wrap0<T> = { layer0: T };
type Wrap1<T> = { layer1: T };
type Wrap2<T> = { layer2: T };
type Wrap3<T> = { layer3: T };
type Wrap4<T> = { layer4: T };
type Wrap5<T> = { layer5: T };
type Wrap6<T> = { layer6: T };
type Wrap7<T> = { layer7: T };
type Wrap8<T> = { layer8: T };
type Wrap9<T> = { layer9: T };
type Wrap10<T> = { layer10: T };
type Wrap11<T> = { layer11: T };
type Wrap12<T> = { layer12: T };
type Wrap13<T> = { layer13: T };
type Wrap14<T> = { layer14: T };
type Wrap15<T> = { layer15: T };
type Wrap16<T> = { layer16: T };
type Wrap17<T> = { layer17: T };
type Wrap18<T> = { layer18: T };
type Wrap19<T> = { layer19: T };
type Wrap20<T> = { layer20: T };
type Wrap21<T> = { layer21: T };
type Wrap22<T> = { layer22: T };
type Wrap23<T> = { layer23: T };
type Wrap24<T> = { layer24: T };
type Wrap25<T> = { layer25: T };
type Wrap26<T> = { layer26: T };
type Wrap27<T> = { layer27: T };
type Wrap28<T> = { layer28: T };
type Wrap29<T> = { layer29: T };
type Wrap30<T> = { layer30: T };
type Wrap31<T> = { layer31: T };
type Wrap32<T> = { layer32: T };
type Wrap33<T> = { layer33: T };
type Wrap34<T> = { layer34: T };

// Deep instantiation chain
type DeepWrapped = Wrap0<Wrap1<Wrap2<Wrap3<Wrap4<Wrap5<Wrap6<Wrap7<Wrap8<Wrap9<Wrap10<Wrap11<Wrap12<Wrap13<Wrap14<Wrap15<Wrap16<Wrap17<Wrap18<Wrap19<Wrap20<Wrap21<Wrap22<Wrap23<Wrap24<Wrap25<Wrap26<Wrap27<Wrap28<Wrap29<Wrap30<Wrap31<Wrap32<Wrap33<Wrap34<string>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;

declare const deep: DeepWrapped;
declare function extract<T>(x: Wrap0<T>): T;
const _test = extract(deep);

// Recursive list operations
declare const list: LinkedList<number>;
declare function mapList<T, U>(l: LinkedList<T>, f: (x: T) => U): LinkedList<U>;
const mapped = mapList(list, x => x.toString());