abstract class Class2<T> implements Class<T>, Interface2<T> {}

abstract class Interface<T> {
  void method11({required List<T> b}) {}
  void method2(covariant num b) {}
  void method3(num a, covariant num b) {}
  void method5({required int b}) {}
  void method8(covariant Iterable<T> b) {}
  void method9(Iterable<T> a, covariant Iterable<T> b) {}
}

abstract class Interface2<T> {
  void method1(int a);
  void method2(int b);
  void method3(int a, int b);
  void method7(List<T> a);
  void method8(List<T> b);
  void method9(List<T> a, List<T> b);
  void set setter1(int a);
  void set setter3(List<T> a);
}

class Class<T> extends Super<T> implements Interface<T> {
  void method1(covariant int a);
  void method2(num b);
  void method3(covariant int a, num b);
  void method7(covariant List<T> a);
  void method8(Iterable<T> b);
  void method9(covariant List<T> a, Iterable<T> b);
  void set setter1(covariant int a);
  void set setter3(covariant List<T> a);
}

class Class1<T> implements Class<T> {
  void method1(double a) {}
  void method10({required Set<T> a}) {}
  void method11({required Set<T> b}) {}
  void method2(double b) {}
  void method3(double a, double b) {}
  void method4({required double a}) {}
  void method5({required double b}) {}
  void method7(Set<T> a) {}
  void method8(Set<T> b) {}
  void method9(Set<T> a, Set<T> b) {}
  void set setter1(double a) {}
  void set setter3(Set<T> a) {}
}

class Super<T> {
  void method1(num a) {}
  void method10({required Iterable<T> a}) {}
  void method11({required List<T> b}) {}
  void method2(int b) {}
  void method3(num a, int b) {}
  void method4({required num a}) {}
  void method5({required int b}) {}
  void method7(Iterable<T> a) {}
  void method8(List<T> b) {}
  void method9(Iterable<T> a, List<T> b) {}
  void set setter1(num a) {}
  void set setter3(Iterable<T> a) {}
}

main() {}