// Signature format: 4.0
package androidx.constraintlayout.core {

  public class ArrayLinkedVariables implements androidx.constraintlayout.core.ArrayRow.ArrayRowVariables {
    method public void add(androidx.constraintlayout.core.SolverVariable!, float, boolean);
    method public final void clear();
    method public boolean contains(androidx.constraintlayout.core.SolverVariable!);
    method public void display();
    method public void divideByAmount(float);
    method public final float get(androidx.constraintlayout.core.SolverVariable!);
    method public int getCurrentSize();
    method public int getHead();
    method public final int getId(int);
    method public final int getNextIndice(int);
    method public final float getValue(int);
    method public androidx.constraintlayout.core.SolverVariable! getVariable(int);
    method public float getVariableValue(int);
    method public int indexOf(androidx.constraintlayout.core.SolverVariable!);
    method public void invert();
    method public final void put(androidx.constraintlayout.core.SolverVariable!, float);
    method public final float remove(androidx.constraintlayout.core.SolverVariable!, boolean);
    method public int sizeInBytes();
    method public float use(androidx.constraintlayout.core.ArrayRow!, boolean);
    field protected final androidx.constraintlayout.core.Cache! mCache;
  }

  public class ArrayRow {
    ctor public ArrayRow();
    ctor public ArrayRow(androidx.constraintlayout.core.Cache!);
    method public androidx.constraintlayout.core.ArrayRow! addError(androidx.constraintlayout.core.LinearSystem!, int);
    method public void addError(androidx.constraintlayout.core.SolverVariable!);
    method public void clear();
    method public androidx.constraintlayout.core.ArrayRow! createRowDimensionRatio(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, float);
    method public androidx.constraintlayout.core.ArrayRow! createRowEqualDimension(float, float, float, androidx.constraintlayout.core.SolverVariable!, int, androidx.constraintlayout.core.SolverVariable!, int, androidx.constraintlayout.core.SolverVariable!, int, androidx.constraintlayout.core.SolverVariable!, int);
    method public androidx.constraintlayout.core.ArrayRow! createRowEqualMatchDimensions(float, float, float, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!);
    method public androidx.constraintlayout.core.ArrayRow! createRowEquals(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int);
    method public androidx.constraintlayout.core.ArrayRow! createRowEquals(androidx.constraintlayout.core.SolverVariable!, int);
    method public androidx.constraintlayout.core.ArrayRow! createRowGreaterThan(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int);
    method public androidx.constraintlayout.core.ArrayRow! createRowGreaterThan(androidx.constraintlayout.core.SolverVariable!, int, androidx.constraintlayout.core.SolverVariable!);
    method public androidx.constraintlayout.core.ArrayRow! createRowLowerThan(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int);
    method public androidx.constraintlayout.core.ArrayRow! createRowWithAngle(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, float);
    method public androidx.constraintlayout.core.SolverVariable! getKey();
    method public androidx.constraintlayout.core.SolverVariable! getPivotCandidate(androidx.constraintlayout.core.LinearSystem!, boolean[]!);
    method public void initFromRow(androidx.constraintlayout.core.LinearSystem.Row!);
    method public boolean isEmpty();
    method public androidx.constraintlayout.core.SolverVariable! pickPivot(androidx.constraintlayout.core.SolverVariable!);
    method public void reset();
    method public void updateFromFinalVariable(androidx.constraintlayout.core.LinearSystem!, androidx.constraintlayout.core.SolverVariable!, boolean);
    method public void updateFromRow(androidx.constraintlayout.core.LinearSystem!, androidx.constraintlayout.core.ArrayRow!, boolean);
    method public void updateFromSynonymVariable(androidx.constraintlayout.core.LinearSystem!, androidx.constraintlayout.core.SolverVariable!, boolean);
    method public void updateFromSystem(androidx.constraintlayout.core.LinearSystem!);
    field public androidx.constraintlayout.core.ArrayRow.ArrayRowVariables! variables;
  }

  public static interface ArrayRow.ArrayRowVariables {
    method public void add(androidx.constraintlayout.core.SolverVariable!, float, boolean);
    method public void clear();
    method public boolean contains(androidx.constraintlayout.core.SolverVariable!);
    method public void display();
    method public void divideByAmount(float);
    method public float get(androidx.constraintlayout.core.SolverVariable!);
    method public int getCurrentSize();
    method public androidx.constraintlayout.core.SolverVariable! getVariable(int);
    method public float getVariableValue(int);
    method public int indexOf(androidx.constraintlayout.core.SolverVariable!);
    method public void invert();
    method public void put(androidx.constraintlayout.core.SolverVariable!, float);
    method public float remove(androidx.constraintlayout.core.SolverVariable!, boolean);
    method public int sizeInBytes();
    method public float use(androidx.constraintlayout.core.ArrayRow!, boolean);
  }

  public class Cache {
    ctor public Cache();
  }

  public class GoalRow extends androidx.constraintlayout.core.ArrayRow {
    ctor public GoalRow(androidx.constraintlayout.core.Cache!);
  }

  public class LinearSystem {
    ctor public LinearSystem();
    method public void addCenterPoint(androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.ConstraintWidget!, float, int);
    method public void addCentering(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int, float, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int, int);
    method public void addConstraint(androidx.constraintlayout.core.ArrayRow!);
    method public androidx.constraintlayout.core.ArrayRow! addEquality(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int, int);
    method public void addEquality(androidx.constraintlayout.core.SolverVariable!, int);
    method public void addGreaterBarrier(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int, boolean);
    method public void addGreaterThan(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int, int);
    method public void addLowerBarrier(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int, boolean);
    method public void addLowerThan(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int, int);
    method public void addRatio(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, float, int);
    method public void addSynonym(androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, int);
    method public androidx.constraintlayout.core.SolverVariable! createErrorVariable(int, String!);
    method public androidx.constraintlayout.core.SolverVariable! createExtraVariable();
    method public androidx.constraintlayout.core.SolverVariable! createObjectVariable(Object!);
    method public androidx.constraintlayout.core.ArrayRow! createRow();
    method public static androidx.constraintlayout.core.ArrayRow! createRowDimensionPercent(androidx.constraintlayout.core.LinearSystem!, androidx.constraintlayout.core.SolverVariable!, androidx.constraintlayout.core.SolverVariable!, float);
    method public androidx.constraintlayout.core.SolverVariable! createSlackVariable();
    method public void displayReadableRows();
    method public void displayVariablesReadableRows();
    method public void fillMetrics(androidx.constraintlayout.core.Metrics!);
    method public androidx.constraintlayout.core.Cache! getCache();
    method public int getMemoryUsed();
    method public static androidx.constraintlayout.core.Metrics! getMetrics();
    method public int getNumEquations();
    method public int getNumVariables();
    method public int getObjectVariableValue(Object!);
    method public void minimize() throws java.lang.Exception;
    method public void removeRow(androidx.constraintlayout.core.ArrayRow!);
    method public void reset();
    field public static long ARRAY_ROW_CREATION;
    field public static final boolean DEBUG = false;
    field public static final boolean FULL_DEBUG = false;
    field public static long OPTIMIZED_ARRAY_ROW_CREATION;
    field public static boolean OPTIMIZED_ENGINE;
    field public static boolean SIMPLIFY_SYNONYMS;
    field public static boolean SKIP_COLUMNS;
    field public static boolean USE_BASIC_SYNONYMS;
    field public static boolean USE_DEPENDENCY_ORDERING;
    field public static boolean USE_SYNONYMS;
    field public boolean graphOptimizer;
    field public boolean hasSimpleDefinition;
    field public boolean newgraphOptimizer;
    field public static androidx.constraintlayout.core.Metrics! sMetrics;
  }

  public class Metrics {
    ctor public Metrics();
    method public void copy(androidx.constraintlayout.core.Metrics!);
    method public void reset();
    field public long additionalMeasures;
    field public long bfs;
    field public long constraints;
    field public long determineGroups;
    field public long errors;
    field public long extravariables;
    field public long fullySolved;
    field public long graphOptimizer;
    field public long graphSolved;
    field public long grouping;
    field public long infeasibleDetermineGroups;
    field public long iterations;
    field public long lastTableSize;
    field public long layouts;
    field public long linearSolved;
    field public long mChildCount;
    field public long mEquations;
    field public long mMeasureCalls;
    field public long mMeasureDuration;
    field public int mNumberOfLayouts;
    field public int mNumberOfMeasures;
    field public long mSimpleEquations;
    field public long mSolverPasses;
    field public long mVariables;
    field public long maxRows;
    field public long maxTableSize;
    field public long maxVariables;
    field public long measuredMatchWidgets;
    field public long measuredWidgets;
    field public long measures;
    field public long measuresLayoutDuration;
    field public long measuresWidgetsDuration;
    field public long measuresWrap;
    field public long measuresWrapInfeasible;
    field public long minimize;
    field public long minimizeGoal;
    field public long nonresolvedWidgets;
    field public long optimize;
    field public long pivots;
    field public java.util.ArrayList<java.lang.String!>! problematicLayouts;
    field public long resolutions;
    field public long resolvedWidgets;
    field public long simpleconstraints;
    field public long slackvariables;
    field public long tableSizeIncrease;
    field public long variables;
    field public long widgets;
  }

  public class PriorityGoalRow extends androidx.constraintlayout.core.ArrayRow {
    ctor public PriorityGoalRow(androidx.constraintlayout.core.Cache!);
  }

  public class SolverVariable implements java.lang.Comparable<androidx.constraintlayout.core.SolverVariable> {
    ctor public SolverVariable(androidx.constraintlayout.core.SolverVariable.Type!, String!);
    ctor public SolverVariable(String!, androidx.constraintlayout.core.SolverVariable.Type!);
    method public final void addToRow(androidx.constraintlayout.core.ArrayRow!);
    method public int compareTo(androidx.constraintlayout.core.SolverVariable!);
    method public String! getName();
    method public final void removeFromRow(androidx.constraintlayout.core.ArrayRow!);
    method public void reset();
    method public void setFinalValue(androidx.constraintlayout.core.LinearSystem!, float);
    method public void setName(String!);
    method public void setSynonym(androidx.constraintlayout.core.LinearSystem!, androidx.constraintlayout.core.SolverVariable!, float);
    method public void setType(androidx.constraintlayout.core.SolverVariable.Type!, String!);
    method public final void updateReferencesWithNewDefinition(androidx.constraintlayout.core.LinearSystem!, androidx.constraintlayout.core.ArrayRow!);
    field public static final int STRENGTH_BARRIER = 6; // 0x6
    field public static final int STRENGTH_CENTERING = 7; // 0x7
    field public static final int STRENGTH_EQUALITY = 5; // 0x5
    field public static final int STRENGTH_FIXED = 8; // 0x8
    field public static final int STRENGTH_HIGH = 3; // 0x3
    field public static final int STRENGTH_HIGHEST = 4; // 0x4
    field public static final int STRENGTH_LOW = 1; // 0x1
    field public static final int STRENGTH_MEDIUM = 2; // 0x2
    field public static final int STRENGTH_NONE = 0; // 0x0
    field public float computedValue;
    field public int id;
    field public boolean inGoal;
    field public boolean isFinalValue;
    field public int strength;
    field public int usageInRowCount;
  }

  public enum SolverVariable.Type {
    enum_constant public static final androidx.constraintlayout.core.SolverVariable.Type CONSTANT;
    enum_constant public static final androidx.constraintlayout.core.SolverVariable.Type ERROR;
    enum_constant public static final androidx.constraintlayout.core.SolverVariable.Type SLACK;
    enum_constant public static final androidx.constraintlayout.core.SolverVariable.Type UNKNOWN;
    enum_constant public static final androidx.constraintlayout.core.SolverVariable.Type UNRESTRICTED;
  }

  public class SolverVariableValues implements androidx.constraintlayout.core.ArrayRow.ArrayRowVariables {
    method public void add(androidx.constraintlayout.core.SolverVariable!, float, boolean);
    method public void clear();
    method public boolean contains(androidx.constraintlayout.core.SolverVariable!);
    method public void display();
    method public void divideByAmount(float);
    method public float get(androidx.constraintlayout.core.SolverVariable!);
    method public int getCurrentSize();
    method public androidx.constraintlayout.core.SolverVariable! getVariable(int);
    method public float getVariableValue(int);
    method public int indexOf(androidx.constraintlayout.core.SolverVariable!);
    method public void invert();
    method public void put(androidx.constraintlayout.core.SolverVariable!, float);
    method public float remove(androidx.constraintlayout.core.SolverVariable!, boolean);
    method public int sizeInBytes();
    method public float use(androidx.constraintlayout.core.ArrayRow!, boolean);
    field protected final androidx.constraintlayout.core.Cache! mCache;
  }

}

package androidx.constraintlayout.core.dsl {

  public class Barrier extends androidx.constraintlayout.core.dsl.Helper {
    ctor public Barrier(String!);
    ctor public Barrier(String!, String!);
    method public androidx.constraintlayout.core.dsl.Barrier! addReference(androidx.constraintlayout.core.dsl.Ref!);
    method public androidx.constraintlayout.core.dsl.Barrier! addReference(String!);
    method public androidx.constraintlayout.core.dsl.Constraint.Side! getDirection();
    method public int getMargin();
    method public String! referencesToString();
    method public void setDirection(androidx.constraintlayout.core.dsl.Constraint.Side!);
    method public void setMargin(int);
  }

  public abstract class Chain extends androidx.constraintlayout.core.dsl.Helper {
    ctor public Chain(String!);
    method public androidx.constraintlayout.core.dsl.Chain! addReference(androidx.constraintlayout.core.dsl.Ref!);
    method public androidx.constraintlayout.core.dsl.Chain! addReference(String!);
    method public androidx.constraintlayout.core.dsl.Chain.Style! getStyle();
    method public String! referencesToString();
    method public void setStyle(androidx.constraintlayout.core.dsl.Chain.Style!);
    field protected java.util.ArrayList<androidx.constraintlayout.core.dsl.Ref!>! references;
    field protected static final java.util.Map<androidx.constraintlayout.core.dsl.Chain.Style!,java.lang.String!>! styleMap;
  }

  public class Chain.Anchor {
    method public void build(StringBuilder!);
    method public String! getId();
  }

  public enum Chain.Style {
    enum_constant public static final androidx.constraintlayout.core.dsl.Chain.Style PACKED;
    enum_constant public static final androidx.constraintlayout.core.dsl.Chain.Style SPREAD;
    enum_constant public static final androidx.constraintlayout.core.dsl.Chain.Style SPREAD_INSIDE;
  }

  public class Constraint {
    ctor public Constraint(String!);
    method protected void append(StringBuilder!, String!, float);
    method public String! convertStringArrayToString(String![]!);
    method public androidx.constraintlayout.core.dsl.Constraint.VAnchor! getBaseline();
    method public androidx.constraintlayout.core.dsl.Constraint.VAnchor! getBottom();
    method public float getCircleAngle();
    method public String! getCircleConstraint();
    method public int getCircleRadius();
    method public String! getDimensionRatio();
    method public int getEditorAbsoluteX();
    method public int getEditorAbsoluteY();
    method public androidx.constraintlayout.core.dsl.Constraint.HAnchor! getEnd();
    method public int getHeight();
    method public androidx.constraintlayout.core.dsl.Constraint.Behaviour! getHeightDefault();
    method public int getHeightMax();
    method public int getHeightMin();
    method public float getHeightPercent();
    method public float getHorizontalBias();
    method public androidx.constraintlayout.core.dsl.Constraint.ChainMode! getHorizontalChainStyle();
    method public float getHorizontalWeight();
    method public androidx.constraintlayout.core.dsl.Constraint.HAnchor! getLeft();
    method public String![]! getReferenceIds();
    method public androidx.constraintlayout.core.dsl.Constraint.HAnchor! getRight();
    method public androidx.constraintlayout.core.dsl.Constraint.HAnchor! getStart();
    method public androidx.constraintlayout.core.dsl.Constraint.VAnchor! getTop();
    method public float getVerticalBias();
    method public androidx.constraintlayout.core.dsl.Constraint.ChainMode! getVerticalChainStyle();
    method public float getVerticalWeight();
    method public int getWidth();
    method public androidx.constraintlayout.core.dsl.Constraint.Behaviour! getWidthDefault();
    method public int getWidthMax();
    method public int getWidthMin();
    method public float getWidthPercent();
    method public boolean isConstrainedHeight();
    method public boolean isConstrainedWidth();
    method public void linkToBaseline(androidx.constraintlayout.core.dsl.Constraint.VAnchor!);
    method public void linkToBaseline(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int);
    method public void linkToBaseline(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int, int);
    method public void linkToBottom(androidx.constraintlayout.core.dsl.Constraint.VAnchor!);
    method public void linkToBottom(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int);
    method public void linkToBottom(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int, int);
    method public void linkToEnd(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToEnd(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToEnd(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
    method public void linkToLeft(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToLeft(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToLeft(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
    method public void linkToRight(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToRight(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToRight(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
    method public void linkToStart(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToStart(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToStart(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
    method public void linkToTop(androidx.constraintlayout.core.dsl.Constraint.VAnchor!);
    method public void linkToTop(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int);
    method public void linkToTop(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int, int);
    method public void setCircleAngle(float);
    method public void setCircleConstraint(String!);
    method public void setCircleRadius(int);
    method public void setConstrainedHeight(boolean);
    method public void setConstrainedWidth(boolean);
    method public void setDimensionRatio(String!);
    method public void setEditorAbsoluteX(int);
    method public void setEditorAbsoluteY(int);
    method public void setHeight(int);
    method public void setHeightDefault(androidx.constraintlayout.core.dsl.Constraint.Behaviour!);
    method public void setHeightMax(int);
    method public void setHeightMin(int);
    method public void setHeightPercent(float);
    method public void setHorizontalBias(float);
    method public void setHorizontalChainStyle(androidx.constraintlayout.core.dsl.Constraint.ChainMode!);
    method public void setHorizontalWeight(float);
    method public void setReferenceIds(String![]!);
    method public void setVerticalBias(float);
    method public void setVerticalChainStyle(androidx.constraintlayout.core.dsl.Constraint.ChainMode!);
    method public void setVerticalWeight(float);
    method public void setWidth(int);
    method public void setWidthDefault(androidx.constraintlayout.core.dsl.Constraint.Behaviour!);
    method public void setWidthMax(int);
    method public void setWidthMin(int);
    method public void setWidthPercent(float);
    field public static final androidx.constraintlayout.core.dsl.Constraint! PARENT;
  }

  public class Constraint.Anchor {
    method public void build(StringBuilder!);
    method public String! getId();
  }

  public enum Constraint.Behaviour {
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Behaviour PERCENT;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Behaviour RATIO;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Behaviour RESOLVED;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Behaviour SPREAD;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Behaviour WRAP;
  }

  public enum Constraint.ChainMode {
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.ChainMode PACKED;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.ChainMode SPREAD;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.ChainMode SPREAD_INSIDE;
  }

  public class Constraint.HAnchor extends androidx.constraintlayout.core.dsl.Constraint.Anchor {
  }

  public enum Constraint.HSide {
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.HSide END;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.HSide LEFT;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.HSide RIGHT;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.HSide START;
  }

  public enum Constraint.Side {
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Side BASELINE;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Side BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Side END;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Side LEFT;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Side RIGHT;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Side START;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.Side TOP;
  }

  public class Constraint.VAnchor extends androidx.constraintlayout.core.dsl.Constraint.Anchor {
  }

  public enum Constraint.VSide {
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.VSide BASELINE;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.VSide BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.dsl.Constraint.VSide TOP;
  }

  public class ConstraintSet {
    ctor public ConstraintSet(String!);
    method public void add(androidx.constraintlayout.core.dsl.Constraint!);
    method public void add(androidx.constraintlayout.core.dsl.Helper!);
  }

  public abstract class Guideline extends androidx.constraintlayout.core.dsl.Helper {
    method public int getEnd();
    method public float getPercent();
    method public int getStart();
    method public void setEnd(int);
    method public void setPercent(float);
    method public void setStart(int);
  }

  public class HChain extends androidx.constraintlayout.core.dsl.Chain {
    ctor public HChain(String!);
    ctor public HChain(String!, String!);
    method public androidx.constraintlayout.core.dsl.HChain.HAnchor! getEnd();
    method public androidx.constraintlayout.core.dsl.HChain.HAnchor! getLeft();
    method public androidx.constraintlayout.core.dsl.HChain.HAnchor! getRight();
    method public androidx.constraintlayout.core.dsl.HChain.HAnchor! getStart();
    method public void linkToEnd(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToEnd(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToEnd(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
    method public void linkToLeft(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToLeft(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToLeft(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
    method public void linkToRight(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToRight(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToRight(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
    method public void linkToStart(androidx.constraintlayout.core.dsl.Constraint.HAnchor!);
    method public void linkToStart(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int);
    method public void linkToStart(androidx.constraintlayout.core.dsl.Constraint.HAnchor!, int, int);
  }

  public class HChain.HAnchor extends androidx.constraintlayout.core.dsl.Chain.Anchor {
  }

  public class Helper {
    ctor public Helper(String!, androidx.constraintlayout.core.dsl.Helper.HelperType!);
    ctor public Helper(String!, androidx.constraintlayout.core.dsl.Helper.HelperType!, String!);
    method public void append(java.util.Map<java.lang.String!,java.lang.String!>!, StringBuilder!);
    method public java.util.Map<java.lang.String!,java.lang.String!>! convertConfigToMap();
    method public String! getConfig();
    method public String! getId();
    method public androidx.constraintlayout.core.dsl.Helper.HelperType! getType();
    method public static void main(String![]!);
    field protected String! config;
    field protected java.util.Map<java.lang.String!,java.lang.String!>! configMap;
    field protected final String! name;
    field protected static final java.util.Map<androidx.constraintlayout.core.dsl.Constraint.Side!,java.lang.String!>! sideMap;
    field protected androidx.constraintlayout.core.dsl.Helper.HelperType! type;
    field protected static final java.util.Map<androidx.constraintlayout.core.dsl.Helper.Type!,java.lang.String!>! typeMap;
  }

  public static final class Helper.HelperType {
    ctor public Helper.HelperType(String!);
  }

  public enum Helper.Type {
    enum_constant public static final androidx.constraintlayout.core.dsl.Helper.Type BARRIER;
    enum_constant public static final androidx.constraintlayout.core.dsl.Helper.Type HORIZONTAL_CHAIN;
    enum_constant public static final androidx.constraintlayout.core.dsl.Helper.Type HORIZONTAL_GUIDELINE;
    enum_constant public static final androidx.constraintlayout.core.dsl.Helper.Type VERTICAL_CHAIN;
    enum_constant public static final androidx.constraintlayout.core.dsl.Helper.Type VERTICAL_GUIDELINE;
  }

  public class KeyAttribute extends androidx.constraintlayout.core.dsl.Keys {
    ctor public KeyAttribute(int, String!);
    method protected void attributesToString(StringBuilder!);
    method public float getAlpha();
    method public androidx.constraintlayout.core.dsl.KeyAttribute.Fit! getCurveFit();
    method public float getPivotX();
    method public float getPivotY();
    method public float getRotation();
    method public float getRotationX();
    method public float getRotationY();
    method public float getScaleX();
    method public float getScaleY();
    method public String! getTarget();
    method public String! getTransitionEasing();
    method public float getTransitionPathRotate();
    method public float getTranslationX();
    method public float getTranslationY();
    method public float getTranslationZ();
    method public androidx.constraintlayout.core.dsl.KeyAttribute.Visibility! getVisibility();
    method public void setAlpha(float);
    method public void setCurveFit(androidx.constraintlayout.core.dsl.KeyAttribute.Fit!);
    method public void setPivotX(float);
    method public void setPivotY(float);
    method public void setRotation(float);
    method public void setRotationX(float);
    method public void setRotationY(float);
    method public void setScaleX(float);
    method public void setScaleY(float);
    method public void setTarget(String!);
    method public void setTransitionEasing(String!);
    method public void setTransitionPathRotate(float);
    method public void setTranslationX(float);
    method public void setTranslationY(float);
    method public void setTranslationZ(float);
    method public void setVisibility(androidx.constraintlayout.core.dsl.KeyAttribute.Visibility!);
    field protected String! TYPE;
  }

  public enum KeyAttribute.Fit {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttribute.Fit LINEAR;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttribute.Fit SPLINE;
  }

  public enum KeyAttribute.Visibility {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttribute.Visibility GONE;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttribute.Visibility INVISIBLE;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttribute.Visibility VISIBLE;
  }

  public class KeyAttributes extends androidx.constraintlayout.core.dsl.Keys {
    method protected void attributesToString(StringBuilder!);
    method public float[]! getAlpha();
    method public androidx.constraintlayout.core.dsl.KeyAttributes.Fit! getCurveFit();
    method public float[]! getPivotX();
    method public float[]! getPivotY();
    method public float[]! getRotation();
    method public float[]! getRotationX();
    method public float[]! getRotationY();
    method public float[]! getScaleX();
    method public float[]! getScaleY();
    method public String![]! getTarget();
    method public String! getTransitionEasing();
    method public float[]! getTransitionPathRotate();
    method public float[]! getTranslationX();
    method public float[]! getTranslationY();
    method public float[]! getTranslationZ();
    method public androidx.constraintlayout.core.dsl.KeyAttributes.Visibility![]! getVisibility();
    method public void setAlpha(float...);
    method public void setCurveFit(androidx.constraintlayout.core.dsl.KeyAttributes.Fit!);
    method public void setPivotX(float...);
    method public void setPivotY(float...);
    method public void setRotation(float...);
    method public void setRotationX(float...);
    method public void setRotationY(float...);
    method public void setScaleX(float[]!);
    method public void setScaleY(float[]!);
    method public void setTarget(String![]!);
    method public void setTransitionEasing(String!);
    method public void setTransitionPathRotate(float...);
    method public void setTranslationX(float[]!);
    method public void setTranslationY(float[]!);
    method public void setTranslationZ(float[]!);
    method public void setVisibility(androidx.constraintlayout.core.dsl.KeyAttributes.Visibility!...);
    field protected String! TYPE;
  }

  public enum KeyAttributes.Fit {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttributes.Fit LINEAR;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttributes.Fit SPLINE;
  }

  public enum KeyAttributes.Visibility {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttributes.Visibility GONE;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttributes.Visibility INVISIBLE;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyAttributes.Visibility VISIBLE;
  }

  public class KeyCycle extends androidx.constraintlayout.core.dsl.KeyAttribute {
    method public float getOffset();
    method public float getPeriod();
    method public float getPhase();
    method public androidx.constraintlayout.core.dsl.KeyCycle.Wave! getShape();
    method public void setOffset(float);
    method public void setPeriod(float);
    method public void setPhase(float);
    method public void setShape(androidx.constraintlayout.core.dsl.KeyCycle.Wave!);
  }

  public enum KeyCycle.Wave {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycle.Wave COS;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycle.Wave REVERSE_SAW;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycle.Wave SAW;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycle.Wave SIN;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycle.Wave SQUARE;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycle.Wave TRIANGLE;
  }

  public class KeyCycles extends androidx.constraintlayout.core.dsl.KeyAttributes {
    method public float[]! getWaveOffset();
    method public float[]! getWavePeriod();
    method public float[]! getWavePhase();
    method public androidx.constraintlayout.core.dsl.KeyCycles.Wave! getWaveShape();
    method public void setWaveOffset(float...);
    method public void setWavePeriod(float...);
    method public void setWavePhase(float...);
    method public void setWaveShape(androidx.constraintlayout.core.dsl.KeyCycles.Wave!);
  }

  public enum KeyCycles.Wave {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycles.Wave COS;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycles.Wave REVERSE_SAW;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycles.Wave SAW;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycles.Wave SIN;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycles.Wave SQUARE;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyCycles.Wave TRIANGLE;
  }

  public class KeyFrames {
    ctor public KeyFrames();
    method public void add(androidx.constraintlayout.core.dsl.Keys!);
  }

  public class KeyPosition extends androidx.constraintlayout.core.dsl.Keys {
    ctor public KeyPosition(String!, int);
    method public int getFrames();
    method public float getPercentHeight();
    method public float getPercentWidth();
    method public float getPercentX();
    method public float getPercentY();
    method public androidx.constraintlayout.core.dsl.KeyPosition.Type! getPositionType();
    method public String! getTarget();
    method public String! getTransitionEasing();
    method public void setFrames(int);
    method public void setPercentHeight(float);
    method public void setPercentWidth(float);
    method public void setPercentX(float);
    method public void setPercentY(float);
    method public void setPositionType(androidx.constraintlayout.core.dsl.KeyPosition.Type!);
    method public void setTarget(String!);
    method public void setTransitionEasing(String!);
  }

  public enum KeyPosition.Type {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyPosition.Type CARTESIAN;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyPosition.Type PATH;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyPosition.Type SCREEN;
  }

  public class KeyPositions extends androidx.constraintlayout.core.dsl.Keys {
    ctor public KeyPositions(int, java.lang.String!...);
    method public int[]! getFrames();
    method public float[]! getPercentHeight();
    method public float[]! getPercentWidth();
    method public float[]! getPercentX();
    method public float[]! getPercentY();
    method public androidx.constraintlayout.core.dsl.KeyPositions.Type! getPositionType();
    method public String![]! getTarget();
    method public String! getTransitionEasing();
    method public void setFrames(int...);
    method public void setPercentHeight(float...);
    method public void setPercentWidth(float...);
    method public void setPercentX(float...);
    method public void setPercentY(float...);
    method public void setPositionType(androidx.constraintlayout.core.dsl.KeyPositions.Type!);
    method public void setTransitionEasing(String!);
  }

  public enum KeyPositions.Type {
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyPositions.Type CARTESIAN;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyPositions.Type PATH;
    enum_constant public static final androidx.constraintlayout.core.dsl.KeyPositions.Type SCREEN;
  }

  public class Keys {
    ctor public Keys();
    method protected void append(StringBuilder!, String!, float);
    method protected void append(StringBuilder!, String!, float[]!);
    method protected void append(StringBuilder!, String!, int);
    method protected void append(StringBuilder!, String!, String!);
    method protected void append(StringBuilder!, String!, String![]!);
    method protected String! unpack(String![]!);
  }

  public class MotionScene {
    ctor public MotionScene();
    method public void addConstraintSet(androidx.constraintlayout.core.dsl.ConstraintSet!);
    method public void addTransition(androidx.constraintlayout.core.dsl.Transition!);
  }

  public class OnSwipe {
    ctor public OnSwipe();
    ctor public OnSwipe(String!, androidx.constraintlayout.core.dsl.OnSwipe.Side!, androidx.constraintlayout.core.dsl.OnSwipe.Drag!);
    method public androidx.constraintlayout.core.dsl.OnSwipe.Mode! getAutoCompleteMode();
    method public androidx.constraintlayout.core.dsl.OnSwipe.Drag! getDragDirection();
    method public float getDragScale();
    method public float getDragThreshold();
    method public String! getLimitBoundsTo();
    method public float getMaxAcceleration();
    method public float getMaxVelocity();
    method public androidx.constraintlayout.core.dsl.OnSwipe.TouchUp! getOnTouchUp();
    method public String! getRotationCenterId();
    method public androidx.constraintlayout.core.dsl.OnSwipe.Boundary! getSpringBoundary();
    method public float getSpringDamping();
    method public float getSpringMass();
    method public float getSpringStiffness();
    method public float getSpringStopThreshold();
    method public String! getTouchAnchorId();
    method public androidx.constraintlayout.core.dsl.OnSwipe.Side! getTouchAnchorSide();
    method public void setAutoCompleteMode(androidx.constraintlayout.core.dsl.OnSwipe.Mode!);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setDragDirection(androidx.constraintlayout.core.dsl.OnSwipe.Drag!);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setDragScale(int);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setDragThreshold(int);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setLimitBoundsTo(String!);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setMaxAcceleration(int);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setMaxVelocity(int);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setOnTouchUp(androidx.constraintlayout.core.dsl.OnSwipe.TouchUp!);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setRotateCenter(String!);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setSpringBoundary(androidx.constraintlayout.core.dsl.OnSwipe.Boundary!);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setSpringDamping(float);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setSpringMass(float);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setSpringStiffness(float);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setSpringStopThreshold(float);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setTouchAnchorId(String!);
    method public androidx.constraintlayout.core.dsl.OnSwipe! setTouchAnchorSide(androidx.constraintlayout.core.dsl.OnSwipe.Side!);
    field public static final int FLAG_DISABLE_POST_SCROLL = 1; // 0x1
    field public static final int FLAG_DISABLE_SCROLL = 2; // 0x2
  }

  public enum OnSwipe.Boundary {
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Boundary BOUNCE_BOTH;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Boundary BOUNCE_END;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Boundary BOUNCE_START;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Boundary OVERSHOOT;
  }

  public enum OnSwipe.Drag {
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag ANTICLOCKWISE;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag CLOCKWISE;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag DOWN;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag END;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag LEFT;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag RIGHT;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag START;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Drag UP;
  }

  public enum OnSwipe.Mode {
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Mode SPRING;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Mode VELOCITY;
  }

  public enum OnSwipe.Side {
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Side BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Side END;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Side LEFT;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Side MIDDLE;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Side RIGHT;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Side START;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.Side TOP;
  }

  public enum OnSwipe.TouchUp {
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp AUTOCOMPLETE;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp DECELERATE;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp DECELERATE_COMPLETE;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp NEVER_COMPLETE_END;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp NEVER_COMPLETE_START;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp STOP;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp TO_END;
    enum_constant public static final androidx.constraintlayout.core.dsl.OnSwipe.TouchUp TO_START;
  }

  public class Ref {
    method public static void addStringToReferences(String!, java.util.ArrayList<androidx.constraintlayout.core.dsl.Ref!>!);
    method public String! getId();
    method public float getPostMargin();
    method public float getPreMargin();
    method public float getWeight();
    method public static float parseFloat(Object!);
    method public static androidx.constraintlayout.core.dsl.Ref! parseStringToRef(String!);
    method public void setId(String!);
    method public void setPostMargin(float);
    method public void setPreMargin(float);
    method public void setWeight(float);
  }

  public class Transition {
    ctor public Transition(String!, String!);
    ctor public Transition(String!, String!, String!);
    method public String! getId();
    method public void setDuration(int);
    method public void setFrom(String!);
    method public void setId(String!);
    method public void setKeyFrames(androidx.constraintlayout.core.dsl.Keys!);
    method public void setOnSwipe(androidx.constraintlayout.core.dsl.OnSwipe!);
    method public void setStagger(float);
    method public void setTo(String!);
  }

  public class VChain extends androidx.constraintlayout.core.dsl.Chain {
    ctor public VChain(String!);
    ctor public VChain(String!, String!);
    method public androidx.constraintlayout.core.dsl.VChain.VAnchor! getBaseline();
    method public androidx.constraintlayout.core.dsl.VChain.VAnchor! getBottom();
    method public androidx.constraintlayout.core.dsl.VChain.VAnchor! getTop();
    method public void linkToBaseline(androidx.constraintlayout.core.dsl.Constraint.VAnchor!);
    method public void linkToBaseline(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int);
    method public void linkToBaseline(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int, int);
    method public void linkToBottom(androidx.constraintlayout.core.dsl.Constraint.VAnchor!);
    method public void linkToBottom(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int);
    method public void linkToBottom(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int, int);
    method public void linkToTop(androidx.constraintlayout.core.dsl.Constraint.VAnchor!);
    method public void linkToTop(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int);
    method public void linkToTop(androidx.constraintlayout.core.dsl.Constraint.VAnchor!, int, int);
  }

  public class VChain.VAnchor extends androidx.constraintlayout.core.dsl.Chain.Anchor {
  }

  public class VGuideline extends androidx.constraintlayout.core.dsl.Guideline {
    ctor public VGuideline(String!);
    ctor public VGuideline(String!, String!);
  }

}

package androidx.constraintlayout.core.motion {

  public class CustomAttribute {
    ctor public CustomAttribute(androidx.constraintlayout.core.motion.CustomAttribute!, Object!);
    ctor public CustomAttribute(String!, androidx.constraintlayout.core.motion.CustomAttribute.AttributeType!);
    ctor public CustomAttribute(String!, androidx.constraintlayout.core.motion.CustomAttribute.AttributeType!, Object!, boolean);
    method public boolean diff(androidx.constraintlayout.core.motion.CustomAttribute!);
    method public androidx.constraintlayout.core.motion.CustomAttribute.AttributeType! getType();
    method public float getValueToInterpolate();
    method public void getValuesToInterpolate(float[]!);
    method public static int hsvToRgb(float, float, float);
    method public boolean isContinuous();
    method public int numberOfInterpolatedValues();
    method public void setColorValue(int);
    method public void setFloatValue(float);
    method public void setIntValue(int);
    method public void setStringValue(String!);
    method public void setValue(float[]!);
    method public void setValue(Object!);
  }

  public enum CustomAttribute.AttributeType {
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType BOOLEAN_TYPE;
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType COLOR_DRAWABLE_TYPE;
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType COLOR_TYPE;
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType DIMENSION_TYPE;
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType FLOAT_TYPE;
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType INT_TYPE;
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType REFERENCE_TYPE;
    enum_constant public static final androidx.constraintlayout.core.motion.CustomAttribute.AttributeType STRING_TYPE;
  }

  public class CustomVariable {
    ctor public CustomVariable(androidx.constraintlayout.core.motion.CustomVariable!);
    ctor public CustomVariable(androidx.constraintlayout.core.motion.CustomVariable!, Object!);
    ctor public CustomVariable(String!, int);
    ctor public CustomVariable(String!, int, boolean);
    ctor public CustomVariable(String!, int, float);
    ctor public CustomVariable(String!, int, int);
    ctor public CustomVariable(String!, int, Object!);
    ctor public CustomVariable(String!, int, String!);
    method public void applyToWidget(androidx.constraintlayout.core.motion.MotionWidget!);
    method public static String! colorString(int);
    method public androidx.constraintlayout.core.motion.CustomVariable! copy();
    method public boolean diff(androidx.constraintlayout.core.motion.CustomVariable!);
    method public boolean getBooleanValue();
    method public int getColorValue();
    method public float getFloatValue();
    method public int getIntegerValue();
    method public int getInterpolatedColor(float[]!);
    method public String! getName();
    method public String! getStringValue();
    method public int getType();
    method public float getValueToInterpolate();
    method public void getValuesToInterpolate(float[]!);
    method public static int hsvToRgb(float, float, float);
    method public boolean isContinuous();
    method public int numberOfInterpolatedValues();
    method public static int rgbaTocColor(float, float, float, float);
    method public void setBooleanValue(boolean);
    method public void setFloatValue(float);
    method public void setIntValue(int);
    method public void setInterpolatedValue(androidx.constraintlayout.core.motion.MotionWidget!, float[]!);
    method public void setStringValue(String!);
    method public void setValue(float[]!);
    method public void setValue(Object!);
  }

  public class Motion implements androidx.constraintlayout.core.motion.utils.TypedValues {
    ctor public Motion(androidx.constraintlayout.core.motion.MotionWidget!);
    method public void addKey(androidx.constraintlayout.core.motion.key.MotionKey!);
    method public int buildKeyFrames(float[]!, int[]!, int[]!);
    method public void buildPath(float[]!, int);
    method public void buildRect(float, float[]!, int);
    method public String! getAnimateRelativeTo();
    method public void getCenter(double, float[]!, float[]!);
    method public float getCenterX();
    method public float getCenterY();
    method public void getDpDt(float, float, float, float[]!);
    method public int getDrawPath();
    method public float getFinalHeight();
    method public float getFinalWidth();
    method public float getFinalX();
    method public float getFinalY();
    method public int getId(String!);
    method public androidx.constraintlayout.core.motion.MotionPaths! getKeyFrame(int);
    method public int getKeyFrameInfo(int, int[]!);
    method public int getKeyFramePositions(int[]!, float[]!);
    method public float getMotionStagger();
    method public float getStartHeight();
    method public float getStartWidth();
    method public float getStartX();
    method public float getStartY();
    method public int getTransformPivotTarget();
    method public androidx.constraintlayout.core.motion.MotionWidget! getView();
    method public boolean interpolate(androidx.constraintlayout.core.motion.MotionWidget!, float, long, androidx.constraintlayout.core.motion.utils.KeyCache!);
    method public void setDrawPath(int);
    method public void setEnd(androidx.constraintlayout.core.motion.MotionWidget!);
    method public void setIdString(String!);
    method public void setPathMotionArc(int);
    method public void setStaggerOffset(float);
    method public void setStaggerScale(float);
    method public void setStart(androidx.constraintlayout.core.motion.MotionWidget!);
    method public void setStartState(androidx.constraintlayout.core.motion.utils.ViewState!, androidx.constraintlayout.core.motion.MotionWidget!, int, int, int);
    method public void setTransformPivotTarget(int);
    method public boolean setValue(int, boolean);
    method public boolean setValue(int, float);
    method public boolean setValue(int, int);
    method public boolean setValue(int, String!);
    method public void setView(androidx.constraintlayout.core.motion.MotionWidget!);
    method public void setup(int, int, float, long);
    method public void setupRelative(androidx.constraintlayout.core.motion.Motion!);
    field public static final int DRAW_PATH_AS_CONFIGURED = 4; // 0x4
    field public static final int DRAW_PATH_BASIC = 1; // 0x1
    field public static final int DRAW_PATH_CARTESIAN = 3; // 0x3
    field public static final int DRAW_PATH_NONE = 0; // 0x0
    field public static final int DRAW_PATH_RECTANGLE = 5; // 0x5
    field public static final int DRAW_PATH_RELATIVE = 2; // 0x2
    field public static final int DRAW_PATH_SCREEN = 6; // 0x6
    field public static final int HORIZONTAL_PATH_X = 2; // 0x2
    field public static final int HORIZONTAL_PATH_Y = 3; // 0x3
    field public static final int PATH_PERCENT = 0; // 0x0
    field public static final int PATH_PERPENDICULAR = 1; // 0x1
    field public static final int ROTATION_LEFT = 2; // 0x2
    field public static final int ROTATION_RIGHT = 1; // 0x1
    field public static final int VERTICAL_PATH_X = 4; // 0x4
    field public static final int VERTICAL_PATH_Y = 5; // 0x5
    field public String! mId;
  }

  public class MotionPaths implements java.lang.Comparable<androidx.constraintlayout.core.motion.MotionPaths> {
    ctor public MotionPaths();
    ctor public MotionPaths(int, int, androidx.constraintlayout.core.motion.key.MotionKeyPosition!, androidx.constraintlayout.core.motion.MotionPaths!, androidx.constraintlayout.core.motion.MotionPaths!);
    method public void applyParameters(androidx.constraintlayout.core.motion.MotionWidget!);
    method public int compareTo(androidx.constraintlayout.core.motion.MotionPaths!);
    method public void configureRelativeTo(androidx.constraintlayout.core.motion.Motion!);
    method public void setupRelative(androidx.constraintlayout.core.motion.Motion!, androidx.constraintlayout.core.motion.MotionPaths!);
    field public static final int CARTESIAN = 0; // 0x0
    field public static final boolean DEBUG = false;
    field public static final boolean OLD_WAY = false;
    field public static final int PERPENDICULAR = 1; // 0x1
    field public static final int SCREEN = 2; // 0x2
    field public static final String TAG = "MotionPaths";
    field public String! mId;
  }

  public class MotionWidget implements androidx.constraintlayout.core.motion.utils.TypedValues {
    ctor public MotionWidget();
    ctor public MotionWidget(androidx.constraintlayout.core.state.WidgetFrame!);
    method public androidx.constraintlayout.core.motion.MotionWidget! findViewById(int);
    method public float getAlpha();
    method public int getBottom();
    method public androidx.constraintlayout.core.motion.CustomVariable! getCustomAttribute(String!);
    method public java.util.Set<java.lang.String!>! getCustomAttributeNames();
    method public int getHeight();
    method public int getId(String!);
    method public int getLeft();
    method public String! getName();
    method public androidx.constraintlayout.core.motion.MotionWidget! getParent();
    method public float getPivotX();
    method public float getPivotY();
    method public int getRight();
    method public float getRotationX();
    method public float getRotationY();
    method public float getRotationZ();
    method public float getScaleX();
    method public float getScaleY();
    method public int getTop();
    method public float getTranslationX();
    method public float getTranslationY();
    method public float getTranslationZ();
    method public float getValueAttributes(int);
    method public int getVisibility();
    method public androidx.constraintlayout.core.state.WidgetFrame! getWidgetFrame();
    method public int getWidth();
    method public int getX();
    method public int getY();
    method public void layout(int, int, int, int);
    method public void setBounds(int, int, int, int);
    method public void setCustomAttribute(String!, int, boolean);
    method public void setCustomAttribute(String!, int, float);
    method public void setCustomAttribute(String!, int, int);
    method public void setCustomAttribute(String!, int, String!);
    method public void setInterpolatedValue(androidx.constraintlayout.core.motion.CustomAttribute!, float[]!);
    method public void setPivotX(float);
    method public void setPivotY(float);
    method public void setRotationX(float);
    method public void setRotationY(float);
    method public void setRotationZ(float);
    method public void setScaleX(float);
    method public void setScaleY(float);
    method public void setTranslationX(float);
    method public void setTranslationY(float);
    method public void setTranslationZ(float);
    method public boolean setValue(int, boolean);
    method public boolean setValue(int, float);
    method public boolean setValue(int, int);
    method public boolean setValue(int, String!);
    method public boolean setValueAttributes(int, float);
    method public boolean setValueMotion(int, float);
    method public boolean setValueMotion(int, int);
    method public boolean setValueMotion(int, String!);
    method public void setVisibility(int);
    method public void updateMotion(androidx.constraintlayout.core.motion.utils.TypedValues!);
    field public static final int FILL_PARENT = -1; // 0xffffffff
    field public static final int GONE_UNSET = -2147483648; // 0x80000000
    field public static final int INVISIBLE = 0; // 0x0
    field public static final int MATCH_CONSTRAINT = 0; // 0x0
    field public static final int MATCH_CONSTRAINT_WRAP = 1; // 0x1
    field public static final int MATCH_PARENT = -1; // 0xffffffff
    field public static final int PARENT_ID = 0; // 0x0
    field public static final int ROTATE_LEFT_OF_PORTRATE = 4; // 0x4
    field public static final int ROTATE_NONE = 0; // 0x0
    field public static final int ROTATE_PORTRATE_OF_LEFT = 2; // 0x2
    field public static final int ROTATE_PORTRATE_OF_RIGHT = 1; // 0x1
    field public static final int ROTATE_RIGHT_OF_PORTRATE = 3; // 0x3
    field public static final int UNSET = -1; // 0xffffffff
    field public static final int VISIBILITY_MODE_IGNORE = 1; // 0x1
    field public static final int VISIBILITY_MODE_NORMAL = 0; // 0x0
    field public static final int VISIBLE = 4; // 0x4
    field public static final int WRAP_CONTENT = -2; // 0xfffffffe
  }

  public static class MotionWidget.Motion {
    ctor public MotionWidget.Motion();
    field public int mAnimateCircleAngleTo;
    field public String! mAnimateRelativeTo;
    field public int mDrawPath;
    field public float mMotionStagger;
    field public int mPathMotionArc;
    field public float mPathRotate;
    field public int mPolarRelativeTo;
    field public int mQuantizeInterpolatorID;
    field public String! mQuantizeInterpolatorString;
    field public int mQuantizeInterpolatorType;
    field public float mQuantizeMotionPhase;
    field public int mQuantizeMotionSteps;
    field public String! mTransitionEasing;
  }

  public static class MotionWidget.PropertySet {
    ctor public MotionWidget.PropertySet();
    field public float alpha;
    field public float mProgress;
    field public int mVisibilityMode;
    field public int visibility;
  }

}

package androidx.constraintlayout.core.motion.key {

  public class MotionConstraintSet {
    ctor public MotionConstraintSet();
    field public static final int ROTATE_LEFT_OF_PORTRATE = 4; // 0x4
    field public static final int ROTATE_NONE = 0; // 0x0
    field public static final int ROTATE_PORTRATE_OF_LEFT = 2; // 0x2
    field public static final int ROTATE_PORTRATE_OF_RIGHT = 1; // 0x1
    field public static final int ROTATE_RIGHT_OF_PORTRATE = 3; // 0x3
    field public String! mIdString;
    field public int mRotate;
  }

  public abstract class MotionKey implements androidx.constraintlayout.core.motion.utils.TypedValues {
    ctor public MotionKey();
    method public abstract void addValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.SplineSet!>!);
    method public abstract androidx.constraintlayout.core.motion.key.MotionKey! clone();
    method public androidx.constraintlayout.core.motion.key.MotionKey! copy(androidx.constraintlayout.core.motion.key.MotionKey!);
    method public abstract void getAttributeNames(java.util.HashSet<java.lang.String!>!);
    method public int getFramePosition();
    method public void setCustomAttribute(String!, int, boolean);
    method public void setCustomAttribute(String!, int, float);
    method public void setCustomAttribute(String!, int, int);
    method public void setCustomAttribute(String!, int, String!);
    method public void setFramePosition(int);
    method public void setInterpolation(java.util.HashMap<java.lang.String!,java.lang.Integer!>!);
    method public boolean setValue(int, boolean);
    method public boolean setValue(int, float);
    method public boolean setValue(int, int);
    method public boolean setValue(int, String!);
    method public androidx.constraintlayout.core.motion.key.MotionKey! setViewId(int);
    field public static final String ALPHA = "alpha";
    field public static final String CUSTOM = "CUSTOM";
    field public static final String ELEVATION = "elevation";
    field public static final String ROTATION = "rotationZ";
    field public static final String ROTATION_X = "rotationX";
    field public static final String SCALE_X = "scaleX";
    field public static final String SCALE_Y = "scaleY";
    field public static final String TRANSITION_PATH_ROTATE = "transitionPathRotate";
    field public static final String TRANSLATION_X = "translationX";
    field public static final String TRANSLATION_Y = "translationY";
    field public static int UNSET;
    field public static final String VISIBILITY = "visibility";
    field public java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.CustomVariable!>! mCustom;
    field public int mFramePosition;
    field public int mType;
  }

  public class MotionKeyAttributes extends androidx.constraintlayout.core.motion.key.MotionKey {
    ctor public MotionKeyAttributes();
    method public void addValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.SplineSet!>!);
    method public androidx.constraintlayout.core.motion.key.MotionKey! clone();
    method public void getAttributeNames(java.util.HashSet<java.lang.String!>!);
    method public int getCurveFit();
    method public int getId(String!);
    method public void printAttributes();
    field public static final int KEY_TYPE = 1; // 0x1
  }

  public class MotionKeyCycle extends androidx.constraintlayout.core.motion.key.MotionKey {
    ctor public MotionKeyCycle();
    method public void addCycleValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.KeyCycleOscillator!>!);
    method public void addValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.SplineSet!>!);
    method public androidx.constraintlayout.core.motion.key.MotionKey! clone();
    method public void dump();
    method public void getAttributeNames(java.util.HashSet<java.lang.String!>!);
    method public int getId(String!);
    method public float getValue(String!);
    method public void printAttributes();
    field public static final int KEY_TYPE = 4; // 0x4
    field public static final int SHAPE_BOUNCE = 6; // 0x6
    field public static final int SHAPE_COS_WAVE = 5; // 0x5
    field public static final int SHAPE_REVERSE_SAW_WAVE = 4; // 0x4
    field public static final int SHAPE_SAW_WAVE = 3; // 0x3
    field public static final int SHAPE_SIN_WAVE = 0; // 0x0
    field public static final int SHAPE_SQUARE_WAVE = 1; // 0x1
    field public static final int SHAPE_TRIANGLE_WAVE = 2; // 0x2
    field public static final String WAVE_OFFSET = "waveOffset";
    field public static final String WAVE_PERIOD = "wavePeriod";
    field public static final String WAVE_PHASE = "wavePhase";
    field public static final String WAVE_SHAPE = "waveShape";
  }

  public class MotionKeyPosition extends androidx.constraintlayout.core.motion.key.MotionKey {
    ctor public MotionKeyPosition();
    method public void addValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.SplineSet!>!);
    method public androidx.constraintlayout.core.motion.key.MotionKey! clone();
    method public void getAttributeNames(java.util.HashSet<java.lang.String!>!);
    method public int getId(String!);
    method public boolean intersects(int, int, androidx.constraintlayout.core.motion.utils.FloatRect!, androidx.constraintlayout.core.motion.utils.FloatRect!, float, float);
    method public void positionAttributes(androidx.constraintlayout.core.motion.MotionWidget!, androidx.constraintlayout.core.motion.utils.FloatRect!, androidx.constraintlayout.core.motion.utils.FloatRect!, float, float, String![]!, float[]!);
    field protected static final float SELECTION_SLOPE = 20.0f;
    field public static final int TYPE_CARTESIAN = 0; // 0x0
    field public static final int TYPE_PATH = 1; // 0x1
    field public static final int TYPE_SCREEN = 2; // 0x2
    field public float mAltPercentX;
    field public float mAltPercentY;
    field public int mCurveFit;
    field public int mDrawPath;
    field public int mPathMotionArc;
    field public float mPercentHeight;
    field public float mPercentWidth;
    field public float mPercentX;
    field public float mPercentY;
    field public int mPositionType;
    field public String! mTransitionEasing;
  }

  public class MotionKeyTimeCycle extends androidx.constraintlayout.core.motion.key.MotionKey {
    ctor public MotionKeyTimeCycle();
    method public void addTimeValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.TimeCycleSplineSet!>!);
    method public void addValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.SplineSet!>!);
    method public androidx.constraintlayout.core.motion.key.MotionKey! clone();
    method public androidx.constraintlayout.core.motion.key.MotionKeyTimeCycle! copy(androidx.constraintlayout.core.motion.key.MotionKey!);
    method public void getAttributeNames(java.util.HashSet<java.lang.String!>!);
    method public int getId(String!);
    field public static final int KEY_TYPE = 3; // 0x3
  }

  public class MotionKeyTrigger extends androidx.constraintlayout.core.motion.key.MotionKey {
    ctor public MotionKeyTrigger();
    method public void addValues(java.util.HashMap<java.lang.String!,androidx.constraintlayout.core.motion.utils.SplineSet!>!);
    method public androidx.constraintlayout.core.motion.key.MotionKey! clone();
    method public void conditionallyFire(float, androidx.constraintlayout.core.motion.MotionWidget!);
    method public androidx.constraintlayout.core.motion.key.MotionKeyTrigger! copy(androidx.constraintlayout.core.motion.key.MotionKey!);
    method public void getAttributeNames(java.util.HashSet<java.lang.String!>!);
    method public int getId(String!);
    field public static final String CROSS = "CROSS";
    field public static final int KEY_TYPE = 5; // 0x5
    field public static final String NEGATIVE_CROSS = "negativeCross";
    field public static final String POSITIVE_CROSS = "positiveCross";
    field public static final String POST_LAYOUT = "postLayout";
    field public static final String TRIGGER_COLLISION_ID = "triggerCollisionId";
    field public static final String TRIGGER_COLLISION_VIEW = "triggerCollisionView";
    field public static final String TRIGGER_ID = "triggerID";
    field public static final String TRIGGER_RECEIVER = "triggerReceiver";
    field public static final String TRIGGER_SLACK = "triggerSlack";
    field public static final int TYPE_CROSS = 312; // 0x138
    field public static final int TYPE_NEGATIVE_CROSS = 310; // 0x136
    field public static final int TYPE_POSITIVE_CROSS = 309; // 0x135
    field public static final int TYPE_POST_LAYOUT = 304; // 0x130
    field public static final int TYPE_TRIGGER_COLLISION_ID = 307; // 0x133
    field public static final int TYPE_TRIGGER_COLLISION_VIEW = 306; // 0x132
    field public static final int TYPE_TRIGGER_ID = 308; // 0x134
    field public static final int TYPE_TRIGGER_RECEIVER = 311; // 0x137
    field public static final int TYPE_TRIGGER_SLACK = 305; // 0x131
    field public static final int TYPE_VIEW_TRANSITION_ON_CROSS = 301; // 0x12d
    field public static final int TYPE_VIEW_TRANSITION_ON_NEGATIVE_CROSS = 303; // 0x12f
    field public static final int TYPE_VIEW_TRANSITION_ON_POSITIVE_CROSS = 302; // 0x12e
    field public static final String VIEW_TRANSITION_ON_CROSS = "viewTransitionOnCross";
    field public static final String VIEW_TRANSITION_ON_NEGATIVE_CROSS = "viewTransitionOnNegativeCross";
    field public static final String VIEW_TRANSITION_ON_POSITIVE_CROSS = "viewTransitionOnPositiveCross";
  }

}

package androidx.constraintlayout.core.motion.parse {

  public class KeyParser {
    ctor public KeyParser();
    method public static void main(String![]!);
    method public static androidx.constraintlayout.core.motion.utils.TypedBundle! parseAttributes(String!);
  }

}

package androidx.constraintlayout.core.motion.utils {

  public class ArcCurveFit extends androidx.constraintlayout.core.motion.utils.CurveFit {
    ctor public ArcCurveFit(int[]!, double[]!, double[]![]!);
    method public void getPos(double, double[]!);
    method public void getPos(double, float[]!);
    method public double getPos(double, int);
    method public void getSlope(double, double[]!);
    method public double getSlope(double, int);
    method public double[]! getTimePoints();
    field public static final int ARC_ABOVE = 5; // 0x5
    field public static final int ARC_BELOW = 4; // 0x4
    field public static final int ARC_START_FLIP = 3; // 0x3
    field public static final int ARC_START_HORIZONTAL = 2; // 0x2
    field public static final int ARC_START_LINEAR = 0; // 0x0
    field public static final int ARC_START_VERTICAL = 1; // 0x1
  }

  public abstract class CurveFit {
    ctor public CurveFit();
    method public static androidx.constraintlayout.core.motion.utils.CurveFit! get(int, double[]!, double[]![]!);
    method public static androidx.constraintlayout.core.motion.utils.CurveFit! getArc(int[]!, double[]!, double[]![]!);
    method public abstract void getPos(double, double[]!);
    method public abstract void getPos(double, float[]!);
    method public abstract double getPos(double, int);
    method public abstract void getSlope(double, double[]!);
    method public abstract double getSlope(double, int);
    method public abstract double[]! getTimePoints();
    field public static final int CONSTANT = 2; // 0x2
    field public static final int LINEAR = 1; // 0x1
    field public static final int SPLINE = 0; // 0x0
  }

  public interface DifferentialInterpolator {
    method public float getInterpolation(float);
    method public float getVelocity();
  }

  public class Easing {
    ctor public Easing();
    method public double get(double);
    method public double getDiff(double);
    method public static androidx.constraintlayout.core.motion.utils.Easing! getInterpolator(String!);
    field public static String![]! NAMED_EASING;
  }

  public class FloatRect {
    ctor public FloatRect();
    method public final float centerX();
    method public final float centerY();
    field public float bottom;
    field public float left;
    field public float right;
    field public float top;
  }

  public class HyperSpline {
    ctor public HyperSpline();
    ctor public HyperSpline(double[]![]!);
    method public double approxLength(androidx.constraintlayout.core.motion.utils.HyperSpline.Cubic![]!);
    method public void getPos(double, double[]!);
    method public void getPos(double, float[]!);
    method public double getPos(double, int);
    method public void getVelocity(double, double[]!);
    method public void setup(double[]![]!);
  }

  public static class HyperSpline.Cubic {
    ctor public HyperSpline.Cubic(double, double, double, double);
    method public double eval(double);
    method public double vel(double);
  }

  public class KeyCache {
    ctor public KeyCache();
    method public float getFloatValue(Object!, String!, int);
    method public void setFloatValue(Object!, String!, int, float);
  }

  public abstract class KeyCycleOscillator {
    ctor public KeyCycleOscillator();
    method public float get(float);
    method public androidx.constraintlayout.core.motion.utils.CurveFit! getCurveFit();
    method public float getSlope(float);
    method public static androidx.constraintlayout.core.motion.utils.KeyCycleOscillator! makeWidgetCycle(String!);
    method protected void setCustom(Object!);
    method public void setPoint(int, int, String!, int, float, float, float, float);
    method public void setPoint(int, int, String!, int, float, float, float, float, Object!);
    method public void setProperty(androidx.constraintlayout.core.motion.MotionWidget!, float);
    method public void setType(String!);
    method public void setup(float);
    method public boolean variesByPath();
    field public int mVariesBy;
  }

  public static class KeyCycleOscillator.PathRotateSet extends androidx.constraintlayout.core.motion.utils.KeyCycleOscillator {
    ctor public KeyCycleOscillator.PathRotateSet(String!);
    method public void setPathRotate(androidx.constraintlayout.core.motion.MotionWidget!, float, double, double);
  }

  public class KeyFrameArray {
    ctor public KeyFrameArray();
  }

  public static class KeyFrameArray.CustomArray {
    ctor public KeyFrameArray.CustomArray();
    method public void append(int, androidx.constraintlayout.core.motion.CustomAttribute!);
    method public void clear();
    method public void dump();
    method public int keyAt(int);
    method public void remove(int);
    method public int size();
    method public androidx.constraintlayout.core.motion.CustomAttribute! valueAt(int);
  }

  public static class KeyFrameArray.CustomVar {
    ctor public KeyFrameArray.CustomVar();
    method public void append(int, androidx.constraintlayout.core.motion.CustomVariable!);
    method public void clear();
    method public void dump();
    method public int keyAt(int);
    method public void remove(int);
    method public int size();
    method public androidx.constraintlayout.core.motion.CustomVariable! valueAt(int);
  }

  public class LinearCurveFit extends androidx.constraintlayout.core.motion.utils.CurveFit {
    ctor public LinearCurveFit(double[]!, double[]![]!);
    method public void getPos(double, double[]!);
    method public void getPos(double, float[]!);
    method public double getPos(double, int);
    method public void getSlope(double, double[]!);
    method public double getSlope(double, int);
    method public double[]! getTimePoints();
  }

  public class MonotonicCurveFit extends androidx.constraintlayout.core.motion.utils.CurveFit {
    ctor public MonotonicCurveFit(double[]!, double[]![]!);
    method public static androidx.constraintlayout.core.motion.utils.MonotonicCurveFit! buildWave(String!);
    method public void getPos(double, double[]!);
    method public void getPos(double, float[]!);
    method public double getPos(double, int);
    method public void getSlope(double, double[]!);
    method public double getSlope(double, int);
    method public double[]! getTimePoints();
  }

  public class Oscillator {
    ctor public Oscillator();
    method public void addPoint(double, float);
    method public double getSlope(double, double, double);
    method public double getValue(double, double);
    method public void normalize();
    method public void setType(int, String!);
    field public static final int BOUNCE = 6; // 0x6
    field public static final int COS_WAVE = 5; // 0x5
    field public static final int CUSTOM = 7; // 0x7
    field public static final int REVERSE_SAW_WAVE = 4; // 0x4
    field public static final int SAW_WAVE = 3; // 0x3
    field public static final int SIN_WAVE = 0; // 0x0
    field public static final int SQUARE_WAVE = 1; // 0x1
    field public static String! TAG;
    field public static final int TRIANGLE_WAVE = 2; // 0x2
  }

  public class Rect {
    ctor public Rect();
    method public int height();
    method public int width();
    field public int bottom;
    field public int left;
    field public int right;
    field public int top;
  }

  public class Schlick extends androidx.constraintlayout.core.motion.utils.Easing {
  }

  public abstract class SplineSet {
    ctor public SplineSet();
    method public float get(float);
    method public androidx.constraintlayout.core.motion.utils.CurveFit! getCurveFit();
    method public float getSlope(float);
    method public static androidx.constraintlayout.core.motion.utils.SplineSet! makeCustomSpline(String!, androidx.constraintlayout.core.motion.utils.KeyFrameArray.CustomArray!);
    method public static androidx.constraintlayout.core.motion.utils.SplineSet! makeCustomSplineSet(String!, androidx.constraintlayout.core.motion.utils.KeyFrameArray.CustomVar!);
    method public static androidx.constraintlayout.core.motion.utils.SplineSet! makeSpline(String!, long);
    method public void setPoint(int, float);
    method public void setProperty(androidx.constraintlayout.core.motion.utils.TypedValues!, float);
    method public void setType(String!);
    method public void setup(int);
    field protected androidx.constraintlayout.core.motion.utils.CurveFit! mCurveFit;
    field protected int[]! mTimePoints;
    field protected float[]! mValues;
  }

  public static class SplineSet.CustomSet extends androidx.constraintlayout.core.motion.utils.SplineSet {
    ctor public SplineSet.CustomSet(String!, androidx.constraintlayout.core.motion.utils.KeyFrameArray.CustomArray!);
    method public void setPoint(int, androidx.constraintlayout.core.motion.CustomAttribute!);
    method public void setProperty(androidx.constraintlayout.core.state.WidgetFrame!, float);
  }

  public static class SplineSet.CustomSpline extends androidx.constraintlayout.core.motion.utils.SplineSet {
    ctor public SplineSet.CustomSpline(String!, androidx.constraintlayout.core.motion.utils.KeyFrameArray.CustomVar!);
    method public void setPoint(int, androidx.constraintlayout.core.motion.CustomVariable!);
    method public void setProperty(androidx.constraintlayout.core.motion.MotionWidget!, float);
  }

  public class SpringStopEngine implements androidx.constraintlayout.core.motion.utils.StopEngine {
    ctor public SpringStopEngine();
    method public String! debug(String!, float);
    method public float getAcceleration();
    method public float getInterpolation(float);
    method public float getVelocity();
    method public float getVelocity(float);
    method public boolean isStopped();
    method public void springConfig(float, float, float, float, float, float, float, int);
  }

  public class StepCurve extends androidx.constraintlayout.core.motion.utils.Easing {
  }

  public interface StopEngine {
    method public String! debug(String!, float);
    method public float getInterpolation(float);
    method public float getVelocity();
    method public float getVelocity(float);
    method public boolean isStopped();
  }

  public class StopLogicEngine implements androidx.constraintlayout.core.motion.utils.StopEngine {
    ctor public StopLogicEngine();
    method public void config(float, float, float, float, float, float);
    method public String! debug(String!, float);
    method public float getInterpolation(float);
    method public float getVelocity();
    method public float getVelocity(float);
    method public boolean isStopped();
  }

  public static class StopLogicEngine.Decelerate implements androidx.constraintlayout.core.motion.utils.StopEngine {
    ctor public StopLogicEngine.Decelerate();
    method public void config(float, float, float);
    method public String! debug(String!, float);
    method public float getInterpolation(float);
    method public float getVelocity();
    method public float getVelocity(float);
    method public boolean isStopped();
  }

  public abstract class TimeCycleSplineSet {
    ctor public TimeCycleSplineSet();
    method protected float calcWave(float);
    method public androidx.constraintlayout.core.motion.utils.CurveFit! getCurveFit();
    method public void setPoint(int, float, float, int, float);
    method protected void setStartTime(long);
    method public void setType(String!);
    method public void setup(int);
    field protected static final int CURVE_OFFSET = 2; // 0x2
    field protected static final int CURVE_PERIOD = 1; // 0x1
    field protected static final int CURVE_VALUE = 0; // 0x0
    field protected float[]! mCache;
    field protected boolean mContinue;
    field protected int mCount;
    field protected androidx.constraintlayout.core.motion.utils.CurveFit! mCurveFit;
    field protected float mLastCycle;
    field protected long mLastTime;
    field protected int[]! mTimePoints;
    field protected String! mType;
    field protected float[]![]! mValues;
    field protected int mWaveShape;
    field protected static float sVal2PI;
  }

  public static class TimeCycleSplineSet.CustomSet extends androidx.constraintlayout.core.motion.utils.TimeCycleSplineSet {
    ctor public TimeCycleSplineSet.CustomSet(String!, androidx.constraintlayout.core.motion.utils.KeyFrameArray.CustomArray!);
    method public void setPoint(int, androidx.constraintlayout.core.motion.CustomAttribute!, float, int, float);
    method public boolean setProperty(androidx.constraintlayout.core.motion.MotionWidget!, float, long, androidx.constraintlayout.core.motion.utils.KeyCache!);
  }

  public static class TimeCycleSplineSet.CustomVarSet extends androidx.constraintlayout.core.motion.utils.TimeCycleSplineSet {
    ctor public TimeCycleSplineSet.CustomVarSet(String!, androidx.constraintlayout.core.motion.utils.KeyFrameArray.CustomVar!);
    method public void setPoint(int, androidx.constraintlayout.core.motion.CustomVariable!, float, int, float);
    method public boolean setProperty(androidx.constraintlayout.core.motion.MotionWidget!, float, long, androidx.constraintlayout.core.motion.utils.KeyCache!);
  }

  protected static class TimeCycleSplineSet.Sort {
    ctor protected TimeCycleSplineSet.Sort();
  }

  public class TypedBundle {
    ctor public TypedBundle();
    method public void add(int, boolean);
    method public void add(int, float);
    method public void add(int, int);
    method public void add(int, String!);
    method public void addIfNotNull(int, String!);
    method public void applyDelta(androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public void applyDelta(androidx.constraintlayout.core.motion.utils.TypedValues!);
    method public void clear();
    method public int getInteger(int);
  }

  public interface TypedValues {
    method public int getId(String!);
    method public boolean setValue(int, boolean);
    method public boolean setValue(int, float);
    method public boolean setValue(int, int);
    method public boolean setValue(int, String!);
    field public static final int BOOLEAN_MASK = 1; // 0x1
    field public static final int FLOAT_MASK = 4; // 0x4
    field public static final int INT_MASK = 2; // 0x2
    field public static final int STRING_MASK = 8; // 0x8
    field public static final String S_CUSTOM = "CUSTOM";
    field public static final int TYPE_FRAME_POSITION = 100; // 0x64
    field public static final int TYPE_TARGET = 101; // 0x65
  }

  public static interface TypedValues.AttributesType {
    method public static int getId(String!);
    method public static int getType(int);
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "KeyAttributes";
    field public static final String S_ALPHA = "alpha";
    field public static final String S_CURVE_FIT = "curveFit";
    field public static final String S_CUSTOM = "CUSTOM";
    field public static final String S_EASING = "easing";
    field public static final String S_ELEVATION = "elevation";
    field public static final String S_FRAME = "frame";
    field public static final String S_PATH_ROTATE = "pathRotate";
    field public static final String S_PIVOT_TARGET = "pivotTarget";
    field public static final String S_PIVOT_X = "pivotX";
    field public static final String S_PIVOT_Y = "pivotY";
    field public static final String S_PROGRESS = "progress";
    field public static final String S_ROTATION_X = "rotationX";
    field public static final String S_ROTATION_Y = "rotationY";
    field public static final String S_ROTATION_Z = "rotationZ";
    field public static final String S_SCALE_X = "scaleX";
    field public static final String S_SCALE_Y = "scaleY";
    field public static final String S_TARGET = "target";
    field public static final String S_TRANSLATION_X = "translationX";
    field public static final String S_TRANSLATION_Y = "translationY";
    field public static final String S_TRANSLATION_Z = "translationZ";
    field public static final String S_VISIBILITY = "visibility";
    field public static final int TYPE_ALPHA = 303; // 0x12f
    field public static final int TYPE_CURVE_FIT = 301; // 0x12d
    field public static final int TYPE_EASING = 317; // 0x13d
    field public static final int TYPE_ELEVATION = 307; // 0x133
    field public static final int TYPE_PATH_ROTATE = 316; // 0x13c
    field public static final int TYPE_PIVOT_TARGET = 318; // 0x13e
    field public static final int TYPE_PIVOT_X = 313; // 0x139
    field public static final int TYPE_PIVOT_Y = 314; // 0x13a
    field public static final int TYPE_PROGRESS = 315; // 0x13b
    field public static final int TYPE_ROTATION_X = 308; // 0x134
    field public static final int TYPE_ROTATION_Y = 309; // 0x135
    field public static final int TYPE_ROTATION_Z = 310; // 0x136
    field public static final int TYPE_SCALE_X = 311; // 0x137
    field public static final int TYPE_SCALE_Y = 312; // 0x138
    field public static final int TYPE_TRANSLATION_X = 304; // 0x130
    field public static final int TYPE_TRANSLATION_Y = 305; // 0x131
    field public static final int TYPE_TRANSLATION_Z = 306; // 0x132
    field public static final int TYPE_VISIBILITY = 302; // 0x12e
  }

  public static interface TypedValues.Custom {
    method public static int getId(String!);
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "Custom";
    field public static final String S_BOOLEAN = "boolean";
    field public static final String S_COLOR = "color";
    field public static final String S_DIMENSION = "dimension";
    field public static final String S_FLOAT = "float";
    field public static final String S_INT = "integer";
    field public static final String S_REFERENCE = "reference";
    field public static final String S_STRING = "string";
    field public static final int TYPE_BOOLEAN = 904; // 0x388
    field public static final int TYPE_COLOR = 902; // 0x386
    field public static final int TYPE_DIMENSION = 905; // 0x389
    field public static final int TYPE_FLOAT = 901; // 0x385
    field public static final int TYPE_INT = 900; // 0x384
    field public static final int TYPE_REFERENCE = 906; // 0x38a
    field public static final int TYPE_STRING = 903; // 0x387
  }

  public static interface TypedValues.CycleType {
    method public static int getId(String!);
    method public static int getType(int);
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "KeyCycle";
    field public static final String S_ALPHA = "alpha";
    field public static final String S_CURVE_FIT = "curveFit";
    field public static final String S_CUSTOM_WAVE_SHAPE = "customWave";
    field public static final String S_EASING = "easing";
    field public static final String S_ELEVATION = "elevation";
    field public static final String S_PATH_ROTATE = "pathRotate";
    field public static final String S_PIVOT_X = "pivotX";
    field public static final String S_PIVOT_Y = "pivotY";
    field public static final String S_PROGRESS = "progress";
    field public static final String S_ROTATION_X = "rotationX";
    field public static final String S_ROTATION_Y = "rotationY";
    field public static final String S_ROTATION_Z = "rotationZ";
    field public static final String S_SCALE_X = "scaleX";
    field public static final String S_SCALE_Y = "scaleY";
    field public static final String S_TRANSLATION_X = "translationX";
    field public static final String S_TRANSLATION_Y = "translationY";
    field public static final String S_TRANSLATION_Z = "translationZ";
    field public static final String S_VISIBILITY = "visibility";
    field public static final String S_WAVE_OFFSET = "offset";
    field public static final String S_WAVE_PERIOD = "period";
    field public static final String S_WAVE_PHASE = "phase";
    field public static final String S_WAVE_SHAPE = "waveShape";
    field public static final int TYPE_ALPHA = 403; // 0x193
    field public static final int TYPE_CURVE_FIT = 401; // 0x191
    field public static final int TYPE_CUSTOM_WAVE_SHAPE = 422; // 0x1a6
    field public static final int TYPE_EASING = 420; // 0x1a4
    field public static final int TYPE_ELEVATION = 307; // 0x133
    field public static final int TYPE_PATH_ROTATE = 416; // 0x1a0
    field public static final int TYPE_PIVOT_X = 313; // 0x139
    field public static final int TYPE_PIVOT_Y = 314; // 0x13a
    field public static final int TYPE_PROGRESS = 315; // 0x13b
    field public static final int TYPE_ROTATION_X = 308; // 0x134
    field public static final int TYPE_ROTATION_Y = 309; // 0x135
    field public static final int TYPE_ROTATION_Z = 310; // 0x136
    field public static final int TYPE_SCALE_X = 311; // 0x137
    field public static final int TYPE_SCALE_Y = 312; // 0x138
    field public static final int TYPE_TRANSLATION_X = 304; // 0x130
    field public static final int TYPE_TRANSLATION_Y = 305; // 0x131
    field public static final int TYPE_TRANSLATION_Z = 306; // 0x132
    field public static final int TYPE_VISIBILITY = 402; // 0x192
    field public static final int TYPE_WAVE_OFFSET = 424; // 0x1a8
    field public static final int TYPE_WAVE_PERIOD = 423; // 0x1a7
    field public static final int TYPE_WAVE_PHASE = 425; // 0x1a9
    field public static final int TYPE_WAVE_SHAPE = 421; // 0x1a5
  }

  public static interface TypedValues.MotionScene {
    method public static int getId(String!);
    method public static int getType(int);
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "MotionScene";
    field public static final String S_DEFAULT_DURATION = "defaultDuration";
    field public static final String S_LAYOUT_DURING_TRANSITION = "layoutDuringTransition";
    field public static final int TYPE_DEFAULT_DURATION = 600; // 0x258
    field public static final int TYPE_LAYOUT_DURING_TRANSITION = 601; // 0x259
  }

  public static interface TypedValues.MotionType {
    method public static int getId(String!);
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "Motion";
    field public static final String S_ANIMATE_CIRCLEANGLE_TO = "AnimateCircleAngleTo";
    field public static final String S_ANIMATE_RELATIVE_TO = "AnimateRelativeTo";
    field public static final String S_DRAW_PATH = "DrawPath";
    field public static final String S_EASING = "TransitionEasing";
    field public static final String S_PATHMOTION_ARC = "PathMotionArc";
    field public static final String S_PATH_ROTATE = "PathRotate";
    field public static final String S_POLAR_RELATIVETO = "PolarRelativeTo";
    field public static final String S_QUANTIZE_INTERPOLATOR = "QuantizeInterpolator";
    field public static final String S_QUANTIZE_INTERPOLATOR_ID = "QuantizeInterpolatorID";
    field public static final String S_QUANTIZE_INTERPOLATOR_TYPE = "QuantizeInterpolatorType";
    field public static final String S_QUANTIZE_MOTIONSTEPS = "QuantizeMotionSteps";
    field public static final String S_QUANTIZE_MOTION_PHASE = "QuantizeMotionPhase";
    field public static final String S_STAGGER = "Stagger";
    field public static final int TYPE_ANIMATE_CIRCLEANGLE_TO = 606; // 0x25e
    field public static final int TYPE_ANIMATE_RELATIVE_TO = 605; // 0x25d
    field public static final int TYPE_DRAW_PATH = 608; // 0x260
    field public static final int TYPE_EASING = 603; // 0x25b
    field public static final int TYPE_PATHMOTION_ARC = 607; // 0x25f
    field public static final int TYPE_PATH_ROTATE = 601; // 0x259
    field public static final int TYPE_POLAR_RELATIVETO = 609; // 0x261
    field public static final int TYPE_QUANTIZE_INTERPOLATOR = 604; // 0x25c
    field public static final int TYPE_QUANTIZE_INTERPOLATOR_ID = 612; // 0x264
    field public static final int TYPE_QUANTIZE_INTERPOLATOR_TYPE = 611; // 0x263
    field public static final int TYPE_QUANTIZE_MOTIONSTEPS = 610; // 0x262
    field public static final int TYPE_QUANTIZE_MOTION_PHASE = 602; // 0x25a
    field public static final int TYPE_STAGGER = 600; // 0x258
  }

  public static interface TypedValues.OnSwipe {
    field public static final String AUTOCOMPLETE_MODE = "autocompletemode";
    field public static final String![]! AUTOCOMPLETE_MODE_ENUM;
    field public static final String DRAG_DIRECTION = "dragdirection";
    field public static final String DRAG_SCALE = "dragscale";
    field public static final String DRAG_THRESHOLD = "dragthreshold";
    field public static final String LIMIT_BOUNDS_TO = "limitboundsto";
    field public static final String MAX_ACCELERATION = "maxacceleration";
    field public static final String MAX_VELOCITY = "maxvelocity";
    field public static final String MOVE_WHEN_SCROLLAT_TOP = "movewhenscrollattop";
    field public static final String NESTED_SCROLL_FLAGS = "nestedscrollflags";
    field public static final String![]! NESTED_SCROLL_FLAGS_ENUM;
    field public static final String ON_TOUCH_UP = "ontouchup";
    field public static final String![]! ON_TOUCH_UP_ENUM;
    field public static final String ROTATION_CENTER_ID = "rotationcenterid";
    field public static final String SPRINGS_TOP_THRESHOLD = "springstopthreshold";
    field public static final String SPRING_BOUNDARY = "springboundary";
    field public static final String![]! SPRING_BOUNDARY_ENUM;
    field public static final String SPRING_DAMPING = "springdamping";
    field public static final String SPRING_MASS = "springmass";
    field public static final String SPRING_STIFFNESS = "springstiffness";
    field public static final String TOUCH_ANCHOR_ID = "touchanchorid";
    field public static final String TOUCH_ANCHOR_SIDE = "touchanchorside";
    field public static final String TOUCH_REGION_ID = "touchregionid";
  }

  public static interface TypedValues.PositionType {
    method public static int getId(String!);
    method public static int getType(int);
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "KeyPosition";
    field public static final String S_DRAWPATH = "drawPath";
    field public static final String S_PERCENT_HEIGHT = "percentHeight";
    field public static final String S_PERCENT_WIDTH = "percentWidth";
    field public static final String S_PERCENT_X = "percentX";
    field public static final String S_PERCENT_Y = "percentY";
    field public static final String S_SIZE_PERCENT = "sizePercent";
    field public static final String S_TRANSITION_EASING = "transitionEasing";
    field public static final int TYPE_CURVE_FIT = 508; // 0x1fc
    field public static final int TYPE_DRAWPATH = 502; // 0x1f6
    field public static final int TYPE_PATH_MOTION_ARC = 509; // 0x1fd
    field public static final int TYPE_PERCENT_HEIGHT = 504; // 0x1f8
    field public static final int TYPE_PERCENT_WIDTH = 503; // 0x1f7
    field public static final int TYPE_PERCENT_X = 506; // 0x1fa
    field public static final int TYPE_PERCENT_Y = 507; // 0x1fb
    field public static final int TYPE_POSITION_TYPE = 510; // 0x1fe
    field public static final int TYPE_SIZE_PERCENT = 505; // 0x1f9
    field public static final int TYPE_TRANSITION_EASING = 501; // 0x1f5
  }

  public static interface TypedValues.TransitionType {
    method public static int getId(String!);
    method public static int getType(int);
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "Transitions";
    field public static final String S_AUTO_TRANSITION = "autoTransition";
    field public static final String S_DURATION = "duration";
    field public static final String S_FROM = "from";
    field public static final String S_INTERPOLATOR = "motionInterpolator";
    field public static final String S_PATH_MOTION_ARC = "pathMotionArc";
    field public static final String S_STAGGERED = "staggered";
    field public static final String S_TO = "to";
    field public static final String S_TRANSITION_FLAGS = "transitionFlags";
    field public static final int TYPE_AUTO_TRANSITION = 704; // 0x2c0
    field public static final int TYPE_DURATION = 700; // 0x2bc
    field public static final int TYPE_FROM = 701; // 0x2bd
    field public static final int TYPE_INTERPOLATOR = 705; // 0x2c1
    field public static final int TYPE_PATH_MOTION_ARC = 509; // 0x1fd
    field public static final int TYPE_STAGGERED = 706; // 0x2c2
    field public static final int TYPE_TO = 702; // 0x2be
    field public static final int TYPE_TRANSITION_FLAGS = 707; // 0x2c3
  }

  public static interface TypedValues.TriggerType {
    method public static int getId(String!);
    field public static final String CROSS = "CROSS";
    field public static final String![]! KEY_WORDS;
    field public static final String NAME = "KeyTrigger";
    field public static final String NEGATIVE_CROSS = "negativeCross";
    field public static final String POSITIVE_CROSS = "positiveCross";
    field public static final String POST_LAYOUT = "postLayout";
    field public static final String TRIGGER_COLLISION_ID = "triggerCollisionId";
    field public static final String TRIGGER_COLLISION_VIEW = "triggerCollisionView";
    field public static final String TRIGGER_ID = "triggerID";
    field public static final String TRIGGER_RECEIVER = "triggerReceiver";
    field public static final String TRIGGER_SLACK = "triggerSlack";
    field public static final int TYPE_CROSS = 312; // 0x138
    field public static final int TYPE_NEGATIVE_CROSS = 310; // 0x136
    field public static final int TYPE_POSITIVE_CROSS = 309; // 0x135
    field public static final int TYPE_POST_LAYOUT = 304; // 0x130
    field public static final int TYPE_TRIGGER_COLLISION_ID = 307; // 0x133
    field public static final int TYPE_TRIGGER_COLLISION_VIEW = 306; // 0x132
    field public static final int TYPE_TRIGGER_ID = 308; // 0x134
    field public static final int TYPE_TRIGGER_RECEIVER = 311; // 0x137
    field public static final int TYPE_TRIGGER_SLACK = 305; // 0x131
    field public static final int TYPE_VIEW_TRANSITION_ON_CROSS = 301; // 0x12d
    field public static final int TYPE_VIEW_TRANSITION_ON_NEGATIVE_CROSS = 303; // 0x12f
    field public static final int TYPE_VIEW_TRANSITION_ON_POSITIVE_CROSS = 302; // 0x12e
    field public static final String VIEW_TRANSITION_ON_CROSS = "viewTransitionOnCross";
    field public static final String VIEW_TRANSITION_ON_NEGATIVE_CROSS = "viewTransitionOnNegativeCross";
    field public static final String VIEW_TRANSITION_ON_POSITIVE_CROSS = "viewTransitionOnPositiveCross";
  }

  public class Utils {
    ctor public Utils();
    method public int getInterpolatedColor(float[]!);
    method public static void log(String!);
    method public static void log(String!, String!);
    method public static void logStack(String!, int);
    method public static void loge(String!, String!);
    method public static int rgbaTocColor(float, float, float, float);
    method public static void setDebugHandle(androidx.constraintlayout.core.motion.utils.Utils.DebugHandle!);
    method public static void socketSend(String!);
  }

  public static interface Utils.DebugHandle {
    method public void message(String!);
  }

  public class VelocityMatrix {
    ctor public VelocityMatrix();
    method public void applyTransform(float, float, int, int, float[]!);
    method public void clear();
    method public void setRotationVelocity(androidx.constraintlayout.core.motion.utils.KeyCycleOscillator!, float);
    method public void setRotationVelocity(androidx.constraintlayout.core.motion.utils.SplineSet!, float);
    method public void setScaleVelocity(androidx.constraintlayout.core.motion.utils.KeyCycleOscillator!, androidx.constraintlayout.core.motion.utils.KeyCycleOscillator!, float);
    method public void setScaleVelocity(androidx.constraintlayout.core.motion.utils.SplineSet!, androidx.constraintlayout.core.motion.utils.SplineSet!, float);
    method public void setTranslationVelocity(androidx.constraintlayout.core.motion.utils.KeyCycleOscillator!, androidx.constraintlayout.core.motion.utils.KeyCycleOscillator!, float);
    method public void setTranslationVelocity(androidx.constraintlayout.core.motion.utils.SplineSet!, androidx.constraintlayout.core.motion.utils.SplineSet!, float);
  }

  public class ViewState {
    ctor public ViewState();
    method public void getState(androidx.constraintlayout.core.motion.MotionWidget!);
    method public int height();
    method public int width();
    field public int bottom;
    field public int left;
    field public int right;
    field public float rotation;
    field public int top;
  }

}

package androidx.constraintlayout.core.parser {

  public class CLArray extends androidx.constraintlayout.core.parser.CLContainer {
    ctor public CLArray(char[]!);
    method public static androidx.constraintlayout.core.parser.CLElement! allocate(char[]!);
  }

  public class CLContainer extends androidx.constraintlayout.core.parser.CLElement {
    ctor public CLContainer(char[]!);
    method public void add(androidx.constraintlayout.core.parser.CLElement!);
    method public static androidx.constraintlayout.core.parser.CLElement! allocate(char[]!);
    method public void clear();
    method public androidx.constraintlayout.core.parser.CLContainer clone();
    method public androidx.constraintlayout.core.parser.CLElement! get(int) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLElement! get(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLArray! getArray(int) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLArray! getArray(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLArray! getArrayOrCreate(String!);
    method public androidx.constraintlayout.core.parser.CLArray! getArrayOrNull(String!);
    method public boolean getBoolean(int) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public boolean getBoolean(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public float getFloat(int) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public float getFloat(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public float getFloatOrNaN(String!);
    method public int getInt(int) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public int getInt(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLObject! getObject(int) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLObject! getObject(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLObject! getObjectOrNull(String!);
    method public androidx.constraintlayout.core.parser.CLElement! getOrNull(int);
    method public androidx.constraintlayout.core.parser.CLElement! getOrNull(String!);
    method public String! getString(int) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public String! getString(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public String! getStringOrNull(int);
    method public String! getStringOrNull(String!);
    method public boolean has(String!);
    method public java.util.ArrayList<java.lang.String!>! names();
    method public void put(String!, androidx.constraintlayout.core.parser.CLElement!);
    method public void putNumber(String!, float);
    method public void putString(String!, String!);
    method public void remove(String!);
    method public int size();
  }

  public class CLElement implements java.lang.Cloneable {
    ctor public CLElement(char[]!);
    method protected void addIndent(StringBuilder!, int);
    method public androidx.constraintlayout.core.parser.CLElement clone();
    method public String! content();
    method public androidx.constraintlayout.core.parser.CLElement! getContainer();
    method protected String! getDebugName();
    method public long getEnd();
    method public float getFloat();
    method public int getInt();
    method public int getLine();
    method public long getStart();
    method protected String! getStrClass();
    method public boolean hasContent();
    method public boolean isDone();
    method public boolean isStarted();
    method public boolean notStarted();
    method public void setContainer(androidx.constraintlayout.core.parser.CLContainer!);
    method public void setEnd(long);
    method public void setLine(int);
    method public void setStart(long);
    method protected String! toFormattedJSON(int, int);
    method protected String! toJSON();
    field protected androidx.constraintlayout.core.parser.CLContainer! mContainer;
    field protected long mEnd;
    field protected long mStart;
    field protected static int sBaseIndent;
    field protected static int sMaxLine;
  }

  public class CLKey extends androidx.constraintlayout.core.parser.CLContainer {
    ctor public CLKey(char[]!);
    method public static androidx.constraintlayout.core.parser.CLElement! allocate(char[]!);
    method public static androidx.constraintlayout.core.parser.CLElement! allocate(String!, androidx.constraintlayout.core.parser.CLElement!);
    method public String! getName();
    method public androidx.constraintlayout.core.parser.CLElement! getValue();
    method public void set(androidx.constraintlayout.core.parser.CLElement!);
  }

  public class CLNumber extends androidx.constraintlayout.core.parser.CLElement {
    ctor public CLNumber(char[]!);
    ctor public CLNumber(float);
    method public static androidx.constraintlayout.core.parser.CLElement! allocate(char[]!);
    method public boolean isInt();
    method public void putValue(float);
  }

  public class CLObject extends androidx.constraintlayout.core.parser.CLContainer implements java.lang.Iterable<androidx.constraintlayout.core.parser.CLKey> {
    ctor public CLObject(char[]!);
    method public static androidx.constraintlayout.core.parser.CLObject! allocate(char[]!);
    method public androidx.constraintlayout.core.parser.CLObject clone();
    method public java.util.Iterator<androidx.constraintlayout.core.parser.CLKey!>! iterator();
    method public String! toFormattedJSON();
    method public String! toFormattedJSON(int, int);
    method public String! toJSON();
  }

  public class CLParser {
    ctor public CLParser(String!);
    method public androidx.constraintlayout.core.parser.CLObject! parse() throws androidx.constraintlayout.core.parser.CLParsingException;
    method public static androidx.constraintlayout.core.parser.CLObject! parse(String!) throws androidx.constraintlayout.core.parser.CLParsingException;
  }

  public class CLParsingException extends java.lang.Exception {
    ctor public CLParsingException(String!, androidx.constraintlayout.core.parser.CLElement!);
    method public String! reason();
  }

  public class CLString extends androidx.constraintlayout.core.parser.CLElement {
    ctor public CLString(char[]!);
    method public static androidx.constraintlayout.core.parser.CLElement! allocate(char[]!);
    method public static androidx.constraintlayout.core.parser.CLString from(String);
  }

  public class CLToken extends androidx.constraintlayout.core.parser.CLElement {
    ctor public CLToken(char[]!);
    method public static androidx.constraintlayout.core.parser.CLElement! allocate(char[]!);
    method public boolean getBoolean() throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.parser.CLToken.Type! getType();
    method public boolean isNull() throws androidx.constraintlayout.core.parser.CLParsingException;
    method public boolean validate(char, long);
  }

}

package androidx.constraintlayout.core.state {

  public class ConstraintReference implements androidx.constraintlayout.core.state.Reference {
    ctor public ConstraintReference(androidx.constraintlayout.core.state.State!);
    method public void addCustomColor(String!, int);
    method public void addCustomFloat(String!, float);
    method public androidx.constraintlayout.core.state.ConstraintReference! alpha(float);
    method public void apply();
    method public void applyWidgetConstraints();
    method public androidx.constraintlayout.core.state.ConstraintReference! baseline();
    method public androidx.constraintlayout.core.state.ConstraintReference! baselineToBaseline(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! baselineToBottom(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! baselineToTop(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! bias(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! bottom();
    method public androidx.constraintlayout.core.state.ConstraintReference! bottomToBottom(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! bottomToTop(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! centerHorizontally(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! centerVertically(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! circularConstraint(Object!, float, float);
    method public androidx.constraintlayout.core.state.ConstraintReference! clear();
    method public androidx.constraintlayout.core.state.ConstraintReference! clearAll();
    method public androidx.constraintlayout.core.state.ConstraintReference! clearHorizontal();
    method public androidx.constraintlayout.core.state.ConstraintReference! clearVertical();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! createConstraintWidget();
    method public androidx.constraintlayout.core.state.ConstraintReference! end();
    method public androidx.constraintlayout.core.state.ConstraintReference! endToEnd(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! endToStart(Object!);
    method public float getAlpha();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getConstraintWidget();
    method public androidx.constraintlayout.core.state.helpers.Facade! getFacade();
    method public androidx.constraintlayout.core.state.Dimension! getHeight();
    method public int getHorizontalChainStyle();
    method public float getHorizontalChainWeight();
    method public Object! getKey();
    method public float getPivotX();
    method public float getPivotY();
    method public float getRotationX();
    method public float getRotationY();
    method public float getRotationZ();
    method public float getScaleX();
    method public float getScaleY();
    method public String! getTag();
    method public float getTranslationX();
    method public float getTranslationY();
    method public float getTranslationZ();
    method public int getVerticalChainStyle(int);
    method public float getVerticalChainWeight();
    method public Object! getView();
    method public androidx.constraintlayout.core.state.Dimension! getWidth();
    method public androidx.constraintlayout.core.state.ConstraintReference! height(androidx.constraintlayout.core.state.Dimension!);
    method public androidx.constraintlayout.core.state.ConstraintReference! horizontalBias(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! left();
    method public androidx.constraintlayout.core.state.ConstraintReference! leftToLeft(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! leftToRight(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! margin(int);
    method public androidx.constraintlayout.core.state.ConstraintReference! margin(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! marginGone(int);
    method public androidx.constraintlayout.core.state.ConstraintReference! marginGone(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! pivotX(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! pivotY(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! right();
    method public androidx.constraintlayout.core.state.ConstraintReference! rightToLeft(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! rightToRight(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! rotationX(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! rotationY(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! rotationZ(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! scaleX(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! scaleY(float);
    method public void setConstraintWidget(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void setFacade(androidx.constraintlayout.core.state.helpers.Facade!);
    method public androidx.constraintlayout.core.state.ConstraintReference! setHeight(androidx.constraintlayout.core.state.Dimension!);
    method public void setHorizontalChainStyle(int);
    method public void setHorizontalChainWeight(float);
    method public void setKey(Object!);
    method public void setTag(String!);
    method public void setVerticalChainStyle(int);
    method public void setVerticalChainWeight(float);
    method public void setView(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! setWidth(androidx.constraintlayout.core.state.Dimension!);
    method public androidx.constraintlayout.core.state.ConstraintReference! start();
    method public androidx.constraintlayout.core.state.ConstraintReference! startToEnd(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! startToStart(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! top();
    method public androidx.constraintlayout.core.state.ConstraintReference! topToBottom(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! topToTop(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! translationX(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! translationY(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! translationZ(float);
    method public void validate() throws java.lang.Exception;
    method public androidx.constraintlayout.core.state.ConstraintReference! verticalBias(float);
    method public androidx.constraintlayout.core.state.ConstraintReference! visibility(int);
    method public androidx.constraintlayout.core.state.ConstraintReference! width(androidx.constraintlayout.core.state.Dimension!);
    field protected Object! mBottomToBottom;
    field protected Object! mBottomToTop;
    field protected Object! mEndToEnd;
    field protected Object! mEndToStart;
    field protected float mHorizontalBias;
    field protected Object! mLeftToLeft;
    field protected Object! mLeftToRight;
    field protected int mMarginBottom;
    field protected int mMarginBottomGone;
    field protected int mMarginEnd;
    field protected int mMarginEndGone;
    field protected int mMarginLeft;
    field protected int mMarginLeftGone;
    field protected int mMarginRight;
    field protected int mMarginRightGone;
    field protected int mMarginStart;
    field protected int mMarginStartGone;
    field protected int mMarginTop;
    field protected int mMarginTopGone;
    field protected Object! mRightToLeft;
    field protected Object! mRightToRight;
    field protected Object! mStartToEnd;
    field protected Object! mStartToStart;
    field protected Object! mTopToBottom;
    field protected Object! mTopToTop;
    field protected float mVerticalBias;
  }

  public static interface ConstraintReference.ConstraintReferenceFactory {
    method public androidx.constraintlayout.core.state.ConstraintReference! create(androidx.constraintlayout.core.state.State!);
  }

  public class ConstraintSetParser {
    ctor public ConstraintSetParser();
    method public static void parseDesignElementsJSON(String!, java.util.ArrayList<androidx.constraintlayout.core.state.ConstraintSetParser.DesignElement!>!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public static void parseJSON(String!, androidx.constraintlayout.core.state.State!, androidx.constraintlayout.core.state.ConstraintSetParser.LayoutVariables!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public static void parseJSON(String!, androidx.constraintlayout.core.state.Transition!, int);
    method public static void parseMotionSceneJSON(androidx.constraintlayout.core.state.CoreMotionScene!, String!);
    method @RestrictTo(androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP) public static void populateState(androidx.constraintlayout.core.parser.CLObject, androidx.constraintlayout.core.state.State, androidx.constraintlayout.core.state.ConstraintSetParser.LayoutVariables) throws androidx.constraintlayout.core.parser.CLParsingException;
  }

  public static class ConstraintSetParser.DesignElement {
    method public String! getId();
    method public java.util.HashMap<java.lang.String!,java.lang.String!>! getParams();
    method public String! getType();
  }

  public static class ConstraintSetParser.LayoutVariables {
    ctor public ConstraintSetParser.LayoutVariables();
    method public void putOverride(String!, float);
  }

  public enum ConstraintSetParser.MotionLayoutDebugFlags {
    enum_constant public static final androidx.constraintlayout.core.state.ConstraintSetParser.MotionLayoutDebugFlags NONE;
    enum_constant public static final androidx.constraintlayout.core.state.ConstraintSetParser.MotionLayoutDebugFlags SHOW_ALL;
    enum_constant public static final androidx.constraintlayout.core.state.ConstraintSetParser.MotionLayoutDebugFlags UNKNOWN;
  }

  public interface CoreMotionScene {
    method public String! getConstraintSet(int);
    method public String! getConstraintSet(String!);
    method public String! getTransition(String!);
    method public void setConstraintSetContent(String!, String!);
    method public void setDebugName(String!);
    method public void setTransitionContent(String!, String!);
  }

  public interface CorePixelDp {
    method public float toPixels(float);
  }

  public class Dimension {
    method public void apply(androidx.constraintlayout.core.state.State!, androidx.constraintlayout.core.widgets.ConstraintWidget!, int);
    method public static androidx.constraintlayout.core.state.Dimension! createFixed(int);
    method public static androidx.constraintlayout.core.state.Dimension! createFixed(Object!);
    method public static androidx.constraintlayout.core.state.Dimension! createParent();
    method public static androidx.constraintlayout.core.state.Dimension! createPercent(Object!, float);
    method public static androidx.constraintlayout.core.state.Dimension! createRatio(String!);
    method public static androidx.constraintlayout.core.state.Dimension! createSpread();
    method public static androidx.constraintlayout.core.state.Dimension! createSuggested(int);
    method public static androidx.constraintlayout.core.state.Dimension! createSuggested(Object!);
    method public static androidx.constraintlayout.core.state.Dimension! createWrap();
    method public boolean equalsFixedValue(int);
    method public androidx.constraintlayout.core.state.Dimension! fixed(int);
    method public androidx.constraintlayout.core.state.Dimension! fixed(Object!);
    method public androidx.constraintlayout.core.state.Dimension! max(int);
    method public androidx.constraintlayout.core.state.Dimension! max(Object!);
    method public androidx.constraintlayout.core.state.Dimension! min(int);
    method public androidx.constraintlayout.core.state.Dimension! min(Object!);
    method public androidx.constraintlayout.core.state.Dimension! percent(Object!, float);
    method public androidx.constraintlayout.core.state.Dimension! ratio(String!);
    method public androidx.constraintlayout.core.state.Dimension! suggested(int);
    method public androidx.constraintlayout.core.state.Dimension! suggested(Object!);
    field public static final Object! FIXED_DIMENSION;
    field public static final Object! PARENT_DIMENSION;
    field public static final Object! PERCENT_DIMENSION;
    field public static final Object! RATIO_DIMENSION;
    field public static final Object! SPREAD_DIMENSION;
    field public static final Object! WRAP_DIMENSION;
  }

  public enum Dimension.Type {
    enum_constant public static final androidx.constraintlayout.core.state.Dimension.Type FIXED;
    enum_constant public static final androidx.constraintlayout.core.state.Dimension.Type MATCH_CONSTRAINT;
    enum_constant public static final androidx.constraintlayout.core.state.Dimension.Type MATCH_PARENT;
    enum_constant public static final androidx.constraintlayout.core.state.Dimension.Type WRAP;
  }

  public class HelperReference extends androidx.constraintlayout.core.state.ConstraintReference implements androidx.constraintlayout.core.state.helpers.Facade {
    ctor public HelperReference(androidx.constraintlayout.core.state.State!, androidx.constraintlayout.core.state.State.Helper!);
    method public androidx.constraintlayout.core.state.HelperReference! add(java.lang.Object!...);
    method public void applyBase();
    method public androidx.constraintlayout.core.widgets.HelperWidget! getHelperWidget();
    method public androidx.constraintlayout.core.state.State.Helper! getType();
    method public void setHelperWidget(androidx.constraintlayout.core.widgets.HelperWidget!);
    field protected final androidx.constraintlayout.core.state.State! mHelperState;
    field protected java.util.ArrayList<java.lang.Object!>! mReferences;
  }

  public interface Interpolator {
    method public float getInterpolation(float);
  }

  public interface Reference {
    method public void apply();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getConstraintWidget();
    method public androidx.constraintlayout.core.state.helpers.Facade! getFacade();
    method public Object! getKey();
    method public void setConstraintWidget(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void setKey(Object!);
  }

  public class Registry {
    ctor public Registry();
    method public String! currentContent(String!);
    method public String! currentLayoutInformation(String!);
    method public static androidx.constraintlayout.core.state.Registry! getInstance();
    method public long getLastModified(String!);
    method public java.util.Set<java.lang.String!>! getLayoutList();
    method public void register(String!, androidx.constraintlayout.core.state.RegistryCallback!);
    method public void setDrawDebug(String!, int);
    method public void setLayoutInformationMode(String!, int);
    method public void unregister(String!, androidx.constraintlayout.core.state.RegistryCallback!);
    method public void updateContent(String!, String!);
    method public void updateDimensions(String!, int, int);
    method public void updateProgress(String!, float);
  }

  public interface RegistryCallback {
    method public String! currentLayoutInformation();
    method public String! currentMotionScene();
    method public long getLastModified();
    method public void onDimensions(int, int);
    method public void onNewMotionScene(String!);
    method public void onProgress(float);
    method public void setDrawDebug(int);
    method public void setLayoutInformationMode(int);
  }

  public class State {
    ctor public State();
    method public void apply(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!);
    method public androidx.constraintlayout.core.state.helpers.BarrierReference! barrier(Object!, androidx.constraintlayout.core.state.State.Direction!);
    method public void baselineNeededFor(Object!);
    method public androidx.constraintlayout.core.state.helpers.AlignHorizontallyReference! centerHorizontally(java.lang.Object!...);
    method public androidx.constraintlayout.core.state.helpers.AlignVerticallyReference! centerVertically(java.lang.Object!...);
    method public androidx.constraintlayout.core.state.ConstraintReference! constraints(Object!);
    method public int convertDimension(Object!);
    method public androidx.constraintlayout.core.state.ConstraintReference! createConstraintReference(Object!);
    method public void directMapping();
    method public androidx.constraintlayout.core.state.helpers.FlowReference! getFlow(Object!, boolean);
    method public androidx.constraintlayout.core.state.helpers.GridReference getGrid(Object, String);
    method public androidx.constraintlayout.core.state.helpers.FlowReference! getHorizontalFlow();
    method public androidx.constraintlayout.core.state.helpers.FlowReference! getHorizontalFlow(java.lang.Object!...);
    method public java.util.ArrayList<java.lang.String!>! getIdsForTag(String!);
    method public androidx.constraintlayout.core.state.helpers.FlowReference! getVerticalFlow();
    method public androidx.constraintlayout.core.state.helpers.FlowReference! getVerticalFlow(java.lang.Object!...);
    method public androidx.constraintlayout.core.state.helpers.GuidelineReference! guideline(Object!, int);
    method public androidx.constraintlayout.core.state.State! height(androidx.constraintlayout.core.state.Dimension!);
    method public androidx.constraintlayout.core.state.HelperReference! helper(Object!, androidx.constraintlayout.core.state.State.Helper!);
    method public androidx.constraintlayout.core.state.helpers.HorizontalChainReference! horizontalChain();
    method public androidx.constraintlayout.core.state.helpers.HorizontalChainReference! horizontalChain(java.lang.Object!...);
    method public androidx.constraintlayout.core.state.helpers.GuidelineReference! horizontalGuideline(Object!);
    method public boolean isBaselineNeeded(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method @Deprecated public boolean isLtr();
    method public boolean isRtl();
    method public void map(Object!, Object!);
    method public void reset();
    method public boolean sameFixedHeight(int);
    method public boolean sameFixedWidth(int);
    method public void setDpToPixel(androidx.constraintlayout.core.state.CorePixelDp!);
    method public androidx.constraintlayout.core.state.State! setHeight(androidx.constraintlayout.core.state.Dimension!);
    method @Deprecated public void setLtr(boolean);
    method public void setRtl(boolean);
    method public void setTag(String!, String!);
    method public androidx.constraintlayout.core.state.State! setWidth(androidx.constraintlayout.core.state.Dimension!);
    method public androidx.constraintlayout.core.state.helpers.VerticalChainReference! verticalChain();
    method public androidx.constraintlayout.core.state.helpers.VerticalChainReference! verticalChain(java.lang.Object!...);
    method public androidx.constraintlayout.core.state.helpers.GuidelineReference! verticalGuideline(Object!);
    method public androidx.constraintlayout.core.state.State! width(androidx.constraintlayout.core.state.Dimension!);
    field public static final Integer PARENT;
    field protected java.util.HashMap<java.lang.Object!,androidx.constraintlayout.core.state.HelperReference!>! mHelperReferences;
    field public final androidx.constraintlayout.core.state.ConstraintReference! mParent;
    field protected java.util.HashMap<java.lang.Object!,androidx.constraintlayout.core.state.Reference!>! mReferences;
  }

  public enum State.Chain {
    method public static androidx.constraintlayout.core.state.State.Chain! getChainByString(String!);
    method public static int getValueByString(String!);
    enum_constant public static final androidx.constraintlayout.core.state.State.Chain PACKED;
    enum_constant public static final androidx.constraintlayout.core.state.State.Chain SPREAD;
    enum_constant public static final androidx.constraintlayout.core.state.State.Chain SPREAD_INSIDE;
    field public static java.util.Map<java.lang.String!,androidx.constraintlayout.core.state.State.Chain!>! chainMap;
    field public static java.util.Map<java.lang.String!,java.lang.Integer!>! valueMap;
  }

  public enum State.Constraint {
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint BASELINE_TO_BASELINE;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint BASELINE_TO_BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint BASELINE_TO_TOP;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint BOTTOM_TO_BASELINE;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint BOTTOM_TO_BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint BOTTOM_TO_TOP;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint CENTER_HORIZONTALLY;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint CENTER_VERTICALLY;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint CIRCULAR_CONSTRAINT;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint END_TO_END;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint END_TO_START;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint LEFT_TO_LEFT;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint LEFT_TO_RIGHT;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint RIGHT_TO_LEFT;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint RIGHT_TO_RIGHT;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint START_TO_END;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint START_TO_START;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint TOP_TO_BASELINE;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint TOP_TO_BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.state.State.Constraint TOP_TO_TOP;
  }

  public enum State.Direction {
    enum_constant public static final androidx.constraintlayout.core.state.State.Direction BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.state.State.Direction END;
    enum_constant public static final androidx.constraintlayout.core.state.State.Direction LEFT;
    enum_constant public static final androidx.constraintlayout.core.state.State.Direction RIGHT;
    enum_constant public static final androidx.constraintlayout.core.state.State.Direction START;
    enum_constant public static final androidx.constraintlayout.core.state.State.Direction TOP;
  }

  public enum State.Helper {
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper ALIGN_HORIZONTALLY;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper ALIGN_VERTICALLY;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper BARRIER;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper COLUMN;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper FLOW;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper GRID;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper HORIZONTAL_CHAIN;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper HORIZONTAL_FLOW;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper LAYER;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper ROW;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper VERTICAL_CHAIN;
    enum_constant public static final androidx.constraintlayout.core.state.State.Helper VERTICAL_FLOW;
  }

  public enum State.Wrap {
    method public static androidx.constraintlayout.core.state.State.Wrap! getChainByString(String!);
    method public static int getValueByString(String!);
    enum_constant public static final androidx.constraintlayout.core.state.State.Wrap ALIGNED;
    enum_constant public static final androidx.constraintlayout.core.state.State.Wrap CHAIN;
    enum_constant public static final androidx.constraintlayout.core.state.State.Wrap NONE;
    field public static java.util.Map<java.lang.String!,java.lang.Integer!>! valueMap;
    field public static java.util.Map<java.lang.String!,androidx.constraintlayout.core.state.State.Wrap!>! wrapMap;
  }

  public class Transition implements androidx.constraintlayout.core.motion.utils.TypedValues {
    ctor public Transition(androidx.constraintlayout.core.state.CorePixelDp);
    method public void addCustomColor(int, String!, String!, int);
    method public void addCustomFloat(int, String!, String!, float);
    method public void addKeyAttribute(String!, androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public void addKeyAttribute(String!, androidx.constraintlayout.core.motion.utils.TypedBundle!, androidx.constraintlayout.core.motion.CustomVariable![]!);
    method public void addKeyCycle(String!, androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public void addKeyPosition(String!, androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public void addKeyPosition(String!, int, int, float, float);
    method public void calcStagger();
    method public void clear();
    method public boolean contains(String!);
    method public float dragToProgress(float, int, int, float, float);
    method public void fillKeyPositions(androidx.constraintlayout.core.state.WidgetFrame!, float[]!, float[]!, float[]!);
    method public androidx.constraintlayout.core.state.Transition.KeyPosition! findNextPosition(String!, int);
    method public androidx.constraintlayout.core.state.Transition.KeyPosition! findPreviousPosition(String!, int);
    method public int getAutoTransition();
    method public androidx.constraintlayout.core.state.WidgetFrame! getEnd(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public androidx.constraintlayout.core.state.WidgetFrame! getEnd(String!);
    method public int getId(String!);
    method public androidx.constraintlayout.core.state.WidgetFrame! getInterpolated(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public androidx.constraintlayout.core.state.WidgetFrame! getInterpolated(String!);
    method public int getInterpolatedHeight();
    method public int getInterpolatedWidth();
    method public androidx.constraintlayout.core.state.Interpolator! getInterpolator();
    method public static androidx.constraintlayout.core.state.Interpolator! getInterpolator(int, String!);
    method public int getKeyFrames(String!, float[]!, int[]!, int[]!);
    method public androidx.constraintlayout.core.motion.Motion! getMotion(String!);
    method public int getNumberKeyPositions(androidx.constraintlayout.core.state.WidgetFrame!);
    method public float[]! getPath(String!);
    method public androidx.constraintlayout.core.state.WidgetFrame! getStart(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public androidx.constraintlayout.core.state.WidgetFrame! getStart(String!);
    method public float getTouchUpProgress(long);
    method public androidx.constraintlayout.core.state.Transition.WidgetState! getWidgetState(String!, androidx.constraintlayout.core.widgets.ConstraintWidget!, int);
    method public boolean hasOnSwipe();
    method public boolean hasPositionKeyframes();
    method public void interpolate(int, int, float);
    method public boolean isEmpty();
    method public boolean isTouchNotDone(float);
    method public void setTouchUp(float, long, float, float);
    method public void setTransitionProperties(androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public boolean setValue(int, boolean);
    method public boolean setValue(int, float);
    method public boolean setValue(int, int);
    method public boolean setValue(int, String!);
    method public void updateFrom(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!, int);
    field public static final int END = 1; // 0x1
    field public static final int INTERPOLATED = 2; // 0x2
    field public static final int START = 0; // 0x0
  }

  public static class Transition.WidgetState {
    ctor public Transition.WidgetState();
    method public androidx.constraintlayout.core.state.WidgetFrame! getFrame(int);
    method public void interpolate(int, int, float, androidx.constraintlayout.core.state.Transition!);
    method public void setKeyAttribute(androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public void setKeyAttribute(androidx.constraintlayout.core.motion.utils.TypedBundle!, androidx.constraintlayout.core.motion.CustomVariable![]!);
    method public void setKeyCycle(androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public void setKeyPosition(androidx.constraintlayout.core.motion.utils.TypedBundle!);
    method public void setPathRelative(androidx.constraintlayout.core.state.Transition.WidgetState!);
    method public void update(androidx.constraintlayout.core.widgets.ConstraintWidget!, int);
  }

  public class TransitionParser {
    ctor public TransitionParser();
    method @RestrictTo(androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP) public static void parse(androidx.constraintlayout.core.parser.CLObject, androidx.constraintlayout.core.state.Transition) throws androidx.constraintlayout.core.parser.CLParsingException;
    method @Deprecated public static void parse(androidx.constraintlayout.core.parser.CLObject!, androidx.constraintlayout.core.state.Transition!, androidx.constraintlayout.core.state.CorePixelDp!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public static void parseKeyFrames(androidx.constraintlayout.core.parser.CLObject!, androidx.constraintlayout.core.state.Transition!) throws androidx.constraintlayout.core.parser.CLParsingException;
  }

  public class WidgetFrame {
    ctor public WidgetFrame();
    ctor public WidgetFrame(androidx.constraintlayout.core.state.WidgetFrame!);
    ctor public WidgetFrame(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void addCustomColor(String!, int);
    method public void addCustomFloat(String!, float);
    method public float centerX();
    method public float centerY();
    method public boolean containsCustom(String);
    method public androidx.constraintlayout.core.motion.CustomVariable! getCustomAttribute(String!);
    method public java.util.Set<java.lang.String!>! getCustomAttributeNames();
    method public int getCustomColor(String!);
    method public float getCustomFloat(String!);
    method public String! getId();
    method public androidx.constraintlayout.core.motion.utils.TypedBundle! getMotionProperties();
    method public int height();
    method public static void interpolate(int, int, androidx.constraintlayout.core.state.WidgetFrame!, androidx.constraintlayout.core.state.WidgetFrame!, androidx.constraintlayout.core.state.WidgetFrame!, androidx.constraintlayout.core.state.Transition!, float);
    method public boolean isDefaultTransform();
    method public StringBuilder! serialize(StringBuilder!);
    method public StringBuilder! serialize(StringBuilder!, boolean);
    method public void setCustomAttribute(String!, int, boolean);
    method public void setCustomAttribute(String!, int, float);
    method public void setCustomAttribute(String!, int, int);
    method public void setCustomAttribute(String!, int, String!);
    method public void setCustomValue(androidx.constraintlayout.core.motion.CustomAttribute!, float[]!);
    method public boolean setValue(String!, androidx.constraintlayout.core.parser.CLElement!) throws androidx.constraintlayout.core.parser.CLParsingException;
    method public androidx.constraintlayout.core.state.WidgetFrame! update();
    method public androidx.constraintlayout.core.state.WidgetFrame! update(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void updateAttributes(androidx.constraintlayout.core.state.WidgetFrame!);
    method public int width();
    field public float alpha;
    field public int bottom;
    field public float interpolatedPos;
    field public int left;
    field public String! name;
    field public static float phone_orientation;
    field public float pivotX;
    field public float pivotY;
    field public int right;
    field public float rotationX;
    field public float rotationY;
    field public float rotationZ;
    field public float scaleX;
    field public float scaleY;
    field public int top;
    field public float translationX;
    field public float translationY;
    field public float translationZ;
    field public int visibility;
    field public androidx.constraintlayout.core.widgets.ConstraintWidget! widget;
  }

}

package androidx.constraintlayout.core.state.helpers {

  public class AlignHorizontallyReference extends androidx.constraintlayout.core.state.HelperReference {
    ctor public AlignHorizontallyReference(androidx.constraintlayout.core.state.State!);
  }

  public class AlignVerticallyReference extends androidx.constraintlayout.core.state.HelperReference {
    ctor public AlignVerticallyReference(androidx.constraintlayout.core.state.State!);
  }

  public class BarrierReference extends androidx.constraintlayout.core.state.HelperReference {
    ctor public BarrierReference(androidx.constraintlayout.core.state.State!);
    method public void setBarrierDirection(androidx.constraintlayout.core.state.State.Direction!);
  }

  public class ChainReference extends androidx.constraintlayout.core.state.HelperReference {
    ctor public ChainReference(androidx.constraintlayout.core.state.State, androidx.constraintlayout.core.state.State.Helper);
    method @RestrictTo(androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP) public void addChainElement(Object, float, float, float, float, float);
    method public void addChainElement(String, float, float, float);
    method public androidx.constraintlayout.core.state.helpers.ChainReference bias(float);
    method public float getBias();
    method protected float getPostMargin(String);
    method protected float getPreMargin(String);
    method public androidx.constraintlayout.core.state.State.Chain getStyle();
    method protected float getWeight(String);
    method public androidx.constraintlayout.core.state.helpers.ChainReference style(androidx.constraintlayout.core.state.State.Chain);
    field protected float mBias;
    field @Deprecated protected java.util.HashMap<java.lang.String!,java.lang.Float!> mMapPostMargin;
    field @Deprecated protected java.util.HashMap<java.lang.String!,java.lang.Float!> mMapPreMargin;
    field @Deprecated protected java.util.HashMap<java.lang.String!,java.lang.Float!> mMapWeights;
    field protected androidx.constraintlayout.core.state.State.Chain mStyle;
  }

  public interface Facade {
    method public void apply();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getConstraintWidget();
  }

  public class FlowReference extends androidx.constraintlayout.core.state.HelperReference {
    ctor public FlowReference(androidx.constraintlayout.core.state.State!, androidx.constraintlayout.core.state.State.Helper!);
    method public void addFlowElement(String!, float, float, float);
    method public float getFirstHorizontalBias();
    method public int getFirstHorizontalStyle();
    method public float getFirstVerticalBias();
    method public int getFirstVerticalStyle();
    method public int getHorizontalAlign();
    method public float getHorizontalBias();
    method public int getHorizontalGap();
    method public int getHorizontalStyle();
    method public float getLastHorizontalBias();
    method public int getLastHorizontalStyle();
    method public float getLastVerticalBias();
    method public int getLastVerticalStyle();
    method public int getMaxElementsWrap();
    method public int getOrientation();
    method public int getPaddingBottom();
    method public int getPaddingLeft();
    method public int getPaddingRight();
    method public int getPaddingTop();
    method protected float getPostMargin(String!);
    method protected float getPreMargin(String!);
    method public int getVerticalAlign();
    method public float getVerticalBias();
    method public int getVerticalGap();
    method public int getVerticalStyle();
    method protected float getWeight(String!);
    method public int getWrapMode();
    method public void setFirstHorizontalBias(float);
    method public void setFirstHorizontalStyle(int);
    method public void setFirstVerticalBias(float);
    method public void setFirstVerticalStyle(int);
    method public void setHorizontalAlign(int);
    method public void setHorizontalGap(int);
    method public void setHorizontalStyle(int);
    method public void setLastHorizontalBias(float);
    method public void setLastHorizontalStyle(int);
    method public void setLastVerticalBias(float);
    method public void setLastVerticalStyle(int);
    method public void setMaxElementsWrap(int);
    method public void setOrientation(int);
    method public void setPaddingBottom(int);
    method public void setPaddingLeft(int);
    method public void setPaddingRight(int);
    method public void setPaddingTop(int);
    method public void setVerticalAlign(int);
    method public void setVerticalGap(int);
    method public void setVerticalStyle(int);
    method public void setWrapMode(int);
    field protected float mFirstHorizontalBias;
    field protected int mFirstHorizontalStyle;
    field protected float mFirstVerticalBias;
    field protected int mFirstVerticalStyle;
    field protected androidx.constraintlayout.core.widgets.Flow! mFlow;
    field protected int mHorizontalAlign;
    field protected int mHorizontalGap;
    field protected int mHorizontalStyle;
    field protected float mLastHorizontalBias;
    field protected int mLastHorizontalStyle;
    field protected float mLastVerticalBias;
    field protected int mLastVerticalStyle;
    field protected java.util.HashMap<java.lang.String!,java.lang.Float!>! mMapPostMargin;
    field protected java.util.HashMap<java.lang.String!,java.lang.Float!>! mMapPreMargin;
    field protected java.util.HashMap<java.lang.String!,java.lang.Float!>! mMapWeights;
    field protected int mMaxElementsWrap;
    field protected int mOrientation;
    field protected int mPaddingBottom;
    field protected int mPaddingLeft;
    field protected int mPaddingRight;
    field protected int mPaddingTop;
    field protected int mVerticalAlign;
    field protected int mVerticalGap;
    field protected int mVerticalStyle;
    field protected int mWrapMode;
  }

  public class GridReference extends androidx.constraintlayout.core.state.HelperReference {
    ctor public GridReference(androidx.constraintlayout.core.state.State, androidx.constraintlayout.core.state.State.Helper);
    method public String? getColumnWeights();
    method public int getColumnsSet();
    method public int[] getFlags();
    method public float getHorizontalGaps();
    method public int getOrientation();
    method public int getPaddingBottom();
    method public int getPaddingEnd();
    method public int getPaddingStart();
    method public int getPaddingTop();
    method public String? getRowWeights();
    method public int getRowsSet();
    method public String? getSkips();
    method public String? getSpans();
    method public float getVerticalGaps();
    method public void setColumnWeights(String);
    method public void setColumnsSet(int);
    method public void setFlags(int[]);
    method public void setFlags(String);
    method public void setHorizontalGaps(float);
    method public void setOrientation(int);
    method public void setPaddingBottom(int);
    method public void setPaddingEnd(int);
    method public void setPaddingStart(int);
    method public void setPaddingTop(int);
    method public void setRowWeights(String);
    method public void setRowsSet(int);
    method public void setSkips(String);
    method public void setSpans(String);
    method public void setVerticalGaps(float);
  }

  public class GuidelineReference implements androidx.constraintlayout.core.state.helpers.Facade androidx.constraintlayout.core.state.Reference {
    ctor public GuidelineReference(androidx.constraintlayout.core.state.State!);
    method public void apply();
    method public androidx.constraintlayout.core.state.helpers.GuidelineReference! end(Object!);
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getConstraintWidget();
    method public androidx.constraintlayout.core.state.helpers.Facade! getFacade();
    method public Object! getKey();
    method public int getOrientation();
    method public androidx.constraintlayout.core.state.helpers.GuidelineReference! percent(float);
    method public void setConstraintWidget(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void setKey(Object!);
    method public void setOrientation(int);
    method public androidx.constraintlayout.core.state.helpers.GuidelineReference! start(Object!);
  }

  public class HorizontalChainReference extends androidx.constraintlayout.core.state.helpers.ChainReference {
    ctor public HorizontalChainReference(androidx.constraintlayout.core.state.State!);
  }

  public class VerticalChainReference extends androidx.constraintlayout.core.state.helpers.ChainReference {
    ctor public VerticalChainReference(androidx.constraintlayout.core.state.State!);
  }

}

package androidx.constraintlayout.core.utils {

  public class GridCore extends androidx.constraintlayout.core.widgets.VirtualLayout {
    ctor public GridCore();
    ctor public GridCore(int, int);
    method public String? getColumnWeights();
    method public androidx.constraintlayout.core.widgets.ConstraintWidgetContainer? getContainer();
    method public int[] getFlags();
    method public float getHorizontalGaps();
    method public int getOrientation();
    method public String? getRowWeights();
    method public float getVerticalGaps();
    method public void setColumnWeights(String);
    method public void setColumns(int);
    method public void setContainer(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer);
    method public void setFlags(int[]);
    method public void setHorizontalGaps(float);
    method public void setOrientation(int);
    method public void setRowWeights(String);
    method public void setRows(int);
    method public void setSkips(String);
    method public void setSpans(CharSequence);
    method public void setVerticalGaps(float);
    field public static final int HORIZONTAL = 0; // 0x0
    field public static final int SPANS_RESPECT_WIDGET_ORDER = 1; // 0x1
    field public static final int SUB_GRID_BY_COL_ROW = 0; // 0x0
    field public static final int VERTICAL = 1; // 0x1
  }

  public class GridEngine {
    ctor public GridEngine();
    ctor public GridEngine(int, int);
    ctor public GridEngine(int, int, int);
    method public int bottomOfWidget(int);
    method public int leftOfWidget(int);
    method public int rightOfWidget(int);
    method public void setColumns(int);
    method public void setNumWidgets(int);
    method public void setOrientation(int);
    method public void setRows(int);
    method public void setSkips(String!);
    method public void setSpans(CharSequence!);
    method public void setup();
    method public int topOfWidget(int);
    field public static final int HORIZONTAL = 0; // 0x0
    field public static final int VERTICAL = 1; // 0x1
  }

}

package androidx.constraintlayout.core.widgets {

  public class Barrier extends androidx.constraintlayout.core.widgets.HelperWidget {
    ctor public Barrier();
    ctor public Barrier(String!);
    method public boolean allSolved();
    method @Deprecated public boolean allowsGoneWidget();
    method public boolean getAllowsGoneWidget();
    method public int getBarrierType();
    method public int getMargin();
    method public int getOrientation();
    method protected void markWidgets();
    method public void setAllowsGoneWidget(boolean);
    method public void setBarrierType(int);
    method public void setMargin(int);
    field public static final int BOTTOM = 3; // 0x3
    field public static final int LEFT = 0; // 0x0
    field public static final int RIGHT = 1; // 0x1
    field public static final int TOP = 2; // 0x2
  }

  public class Chain {
    ctor public Chain();
    method public static void applyChainConstraints(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!, androidx.constraintlayout.core.LinearSystem!, java.util.ArrayList<androidx.constraintlayout.core.widgets.ConstraintWidget!>!, int);
    field public static final boolean USE_CHAIN_OPTIMIZATION = false;
  }

  public class ChainHead {
    ctor public ChainHead(androidx.constraintlayout.core.widgets.ConstraintWidget!, int, boolean);
    method public void define();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getFirst();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getFirstMatchConstraintWidget();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getFirstVisibleWidget();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getHead();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getLast();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getLastMatchConstraintWidget();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getLastVisibleWidget();
    method public float getTotalWeight();
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget! mFirst;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget! mFirstMatchConstraintWidget;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget! mFirstVisibleWidget;
    field protected boolean mHasComplexMatchWeights;
    field protected boolean mHasDefinedWeights;
    field protected boolean mHasRatio;
    field protected boolean mHasUndefinedWeights;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget! mHead;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget! mLast;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget! mLastMatchConstraintWidget;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget! mLastVisibleWidget;
    field protected float mTotalWeight;
    field protected java.util.ArrayList<androidx.constraintlayout.core.widgets.ConstraintWidget!>! mWeightedMatchConstraintsWidgets;
    field protected int mWidgetsCount;
    field protected int mWidgetsMatchCount;
  }

  public class ConstraintAnchor {
    ctor public ConstraintAnchor(androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!);
    method public boolean connect(androidx.constraintlayout.core.widgets.ConstraintAnchor!, int);
    method public boolean connect(androidx.constraintlayout.core.widgets.ConstraintAnchor!, int, int, boolean);
    method public void copyFrom(androidx.constraintlayout.core.widgets.ConstraintAnchor!, java.util.HashMap<androidx.constraintlayout.core.widgets.ConstraintWidget!,androidx.constraintlayout.core.widgets.ConstraintWidget!>!);
    method public void findDependents(int, java.util.ArrayList<androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!>!, androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!);
    method public java.util.HashSet<androidx.constraintlayout.core.widgets.ConstraintAnchor!>! getDependents();
    method public int getFinalValue();
    method public int getMargin();
    method public final androidx.constraintlayout.core.widgets.ConstraintAnchor! getOpposite();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getOwner();
    method public androidx.constraintlayout.core.SolverVariable! getSolverVariable();
    method public androidx.constraintlayout.core.widgets.ConstraintAnchor! getTarget();
    method public androidx.constraintlayout.core.widgets.ConstraintAnchor.Type! getType();
    method public boolean hasCenteredDependents();
    method public boolean hasDependents();
    method public boolean hasFinalValue();
    method public boolean isConnected();
    method public boolean isConnectionAllowed(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public boolean isConnectionAllowed(androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.ConstraintAnchor!);
    method public boolean isSideAnchor();
    method public boolean isSimilarDimensionConnection(androidx.constraintlayout.core.widgets.ConstraintAnchor!);
    method public boolean isValidConnection(androidx.constraintlayout.core.widgets.ConstraintAnchor!);
    method public boolean isVerticalAnchor();
    method public void reset();
    method public void resetFinalResolution();
    method public void resetSolverVariable(androidx.constraintlayout.core.Cache!);
    method public void setFinalValue(int);
    method public void setGoneMargin(int);
    method public void setMargin(int);
    field public int mMargin;
    field public final androidx.constraintlayout.core.widgets.ConstraintWidget! mOwner;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor! mTarget;
    field public final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type! mType;
  }

  public enum ConstraintAnchor.Type {
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type BASELINE;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type BOTTOM;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type CENTER;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type CENTER_X;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type CENTER_Y;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type LEFT;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type NONE;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type RIGHT;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintAnchor.Type TOP;
  }

  public class ConstraintWidget {
    ctor public ConstraintWidget();
    ctor public ConstraintWidget(int, int);
    ctor public ConstraintWidget(int, int, int, int);
    ctor public ConstraintWidget(String!);
    ctor public ConstraintWidget(String!, int, int);
    ctor public ConstraintWidget(String!, int, int, int, int);
    method public void addChildrenToSolverByDependency(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!, androidx.constraintlayout.core.LinearSystem!, java.util.HashSet<androidx.constraintlayout.core.widgets.ConstraintWidget!>!, int, boolean);
    method public void addToSolver(androidx.constraintlayout.core.LinearSystem!, boolean);
    method public boolean allowedInBarrier();
    method public void connect(androidx.constraintlayout.core.widgets.ConstraintAnchor!, androidx.constraintlayout.core.widgets.ConstraintAnchor!, int);
    method public void connect(androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!, androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!);
    method public void connect(androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!, androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!, int);
    method public void connectCircularConstraint(androidx.constraintlayout.core.widgets.ConstraintWidget!, float, int);
    method public void copy(androidx.constraintlayout.core.widgets.ConstraintWidget!, java.util.HashMap<androidx.constraintlayout.core.widgets.ConstraintWidget!,androidx.constraintlayout.core.widgets.ConstraintWidget!>!);
    method public void createObjectVariables(androidx.constraintlayout.core.LinearSystem!);
    method public void ensureMeasureRequested();
    method public void ensureWidgetRuns();
    method public androidx.constraintlayout.core.widgets.ConstraintAnchor! getAnchor(androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!);
    method public java.util.ArrayList<androidx.constraintlayout.core.widgets.ConstraintAnchor!>! getAnchors();
    method public int getBaselineDistance();
    method public float getBiasPercent(int);
    method public int getBottom();
    method public Object! getCompanionWidget();
    method public int getContainerItemSkip();
    method public String! getDebugName();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour! getDimensionBehaviour(int);
    method public float getDimensionRatio();
    method public int getDimensionRatioSide();
    method public boolean getHasBaseline();
    method public int getHeight();
    method public float getHorizontalBiasPercent();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getHorizontalChainControlWidget();
    method public int getHorizontalChainStyle();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour! getHorizontalDimensionBehaviour();
    method public int getHorizontalMargin();
    method public int getLastHorizontalMeasureSpec();
    method public int getLastVerticalMeasureSpec();
    method public int getLeft();
    method public int getLength(int);
    method public int getMaxHeight();
    method public int getMaxWidth();
    method public int getMinHeight();
    method public int getMinWidth();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getNextChainMember(int);
    method public int getOptimizerWrapHeight();
    method public int getOptimizerWrapWidth();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getParent();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getPreviousChainMember(int);
    method public int getRight();
    method protected int getRootX();
    method protected int getRootY();
    method public androidx.constraintlayout.core.widgets.analyzer.WidgetRun! getRun(int);
    method public void getSceneString(StringBuilder!);
    method public int getTop();
    method public String! getType();
    method public float getVerticalBiasPercent();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget! getVerticalChainControlWidget();
    method public int getVerticalChainStyle();
    method public androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour! getVerticalDimensionBehaviour();
    method public int getVerticalMargin();
    method public int getVisibility();
    method public int getWidth();
    method public int getWrapBehaviorInParent();
    method public int getX();
    method public int getY();
    method public boolean hasBaseline();
    method public boolean hasDanglingDimension(int);
    method public boolean hasDependencies();
    method public boolean hasDimensionOverride();
    method public boolean hasResolvedTargets(int, int);
    method public void immediateConnect(androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!, androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!, int, int);
    method public boolean isAnimated();
    method public boolean isHeightWrapContent();
    method public boolean isHorizontalSolvingPassDone();
    method public boolean isInBarrier(int);
    method public boolean isInHorizontalChain();
    method public boolean isInPlaceholder();
    method public boolean isInVerticalChain();
    method public boolean isInVirtualLayout();
    method public boolean isMeasureRequested();
    method public boolean isResolvedHorizontally();
    method public boolean isResolvedVertically();
    method public boolean isRoot();
    method public boolean isSpreadHeight();
    method public boolean isSpreadWidth();
    method public boolean isVerticalSolvingPassDone();
    method public boolean isWidthWrapContent();
    method public void markHorizontalSolvingPassDone();
    method public void markVerticalSolvingPassDone();
    method public boolean oppositeDimensionDependsOn(int);
    method public boolean oppositeDimensionsTied();
    method public void reset();
    method public void resetAllConstraints();
    method public void resetAnchor(androidx.constraintlayout.core.widgets.ConstraintAnchor!);
    method public void resetAnchors();
    method public void resetFinalResolution();
    method public void resetSolverVariables(androidx.constraintlayout.core.Cache!);
    method public void resetSolvingPassFlag();
    method public StringBuilder! serialize(StringBuilder!);
    method public void setAnimated(boolean);
    method public void setBaselineDistance(int);
    method public void setCompanionWidget(Object!);
    method public void setContainerItemSkip(int);
    method public void setDebugName(String!);
    method public void setDebugSolverName(androidx.constraintlayout.core.LinearSystem!, String!);
    method public void setDimension(int, int);
    method public void setDimensionRatio(float, int);
    method public void setDimensionRatio(String!);
    method public void setFinalBaseline(int);
    method public void setFinalFrame(int, int, int, int, int, int);
    method public void setFinalHorizontal(int, int);
    method public void setFinalLeft(int);
    method public void setFinalTop(int);
    method public void setFinalVertical(int, int);
    method public void setFrame(int, int, int);
    method public void setFrame(int, int, int, int);
    method public void setGoneMargin(androidx.constraintlayout.core.widgets.ConstraintAnchor.Type!, int);
    method public void setHasBaseline(boolean);
    method public void setHeight(int);
    method public void setHeightWrapContent(boolean);
    method public void setHorizontalBiasPercent(float);
    method public void setHorizontalChainStyle(int);
    method public void setHorizontalDimension(int, int);
    method public void setHorizontalDimensionBehaviour(androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!);
    method public void setHorizontalMatchStyle(int, int, int, float);
    method public void setHorizontalWeight(float);
    method protected void setInBarrier(int, boolean);
    method public void setInPlaceholder(boolean);
    method public void setInVirtualLayout(boolean);
    method public void setLastMeasureSpec(int, int);
    method public void setLength(int, int);
    method public void setMaxHeight(int);
    method public void setMaxWidth(int);
    method public void setMeasureRequested(boolean);
    method public void setMinHeight(int);
    method public void setMinWidth(int);
    method public void setOffset(int, int);
    method public void setOrigin(int, int);
    method public void setParent(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void setType(String!);
    method public void setVerticalBiasPercent(float);
    method public void setVerticalChainStyle(int);
    method public void setVerticalDimension(int, int);
    method public void setVerticalDimensionBehaviour(androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!);
    method public void setVerticalMatchStyle(int, int, int, float);
    method public void setVerticalWeight(float);
    method public void setVisibility(int);
    method public void setWidth(int);
    method public void setWidthWrapContent(boolean);
    method public void setWrapBehaviorInParent(int);
    method public void setX(int);
    method public void setY(int);
    method public void setupDimensionRatio(boolean, boolean, boolean, boolean);
    method public void updateFromRuns(boolean, boolean);
    method public void updateFromSolver(androidx.constraintlayout.core.LinearSystem!, boolean);
    field public static final int ANCHOR_BASELINE = 4; // 0x4
    field public static final int ANCHOR_BOTTOM = 3; // 0x3
    field public static final int ANCHOR_LEFT = 0; // 0x0
    field public static final int ANCHOR_RIGHT = 1; // 0x1
    field public static final int ANCHOR_TOP = 2; // 0x2
    field public static final int BOTH = 2; // 0x2
    field public static final int CHAIN_PACKED = 2; // 0x2
    field public static final int CHAIN_SPREAD = 0; // 0x0
    field public static final int CHAIN_SPREAD_INSIDE = 1; // 0x1
    field public static float DEFAULT_BIAS;
    field protected static final int DIRECT = 2; // 0x2
    field public static final int GONE = 8; // 0x8
    field public static final int HORIZONTAL = 0; // 0x0
    field public static final int INVISIBLE = 4; // 0x4
    field public static final int MATCH_CONSTRAINT_PERCENT = 2; // 0x2
    field public static final int MATCH_CONSTRAINT_RATIO = 3; // 0x3
    field public static final int MATCH_CONSTRAINT_RATIO_RESOLVED = 4; // 0x4
    field public static final int MATCH_CONSTRAINT_SPREAD = 0; // 0x0
    field public static final int MATCH_CONSTRAINT_WRAP = 1; // 0x1
    field protected static final int SOLVER = 1; // 0x1
    field public static final int UNKNOWN = -1; // 0xffffffff
    field public static final int VERTICAL = 1; // 0x1
    field public static final int VISIBLE = 0; // 0x0
    field public static final int WRAP_BEHAVIOR_HORIZONTAL_ONLY = 1; // 0x1
    field public static final int WRAP_BEHAVIOR_INCLUDED = 0; // 0x0
    field public static final int WRAP_BEHAVIOR_SKIPPED = 3; // 0x3
    field public static final int WRAP_BEHAVIOR_VERTICAL_ONLY = 2; // 0x2
    field public androidx.constraintlayout.core.state.WidgetFrame! frame;
    field public androidx.constraintlayout.core.widgets.analyzer.ChainRun! horizontalChainRun;
    field public int horizontalGroup;
    field public boolean[]! isTerminalWidget;
    field protected java.util.ArrayList<androidx.constraintlayout.core.widgets.ConstraintAnchor!>! mAnchors;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor! mBaseline;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor! mBottom;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor! mCenter;
    field public float mCircleConstraintAngle;
    field public float mDimensionRatio;
    field protected int mDimensionRatioSide;
    field public int mHorizontalResolution;
    field public androidx.constraintlayout.core.widgets.analyzer.HorizontalWidgetRun! mHorizontalRun;
    field public boolean mIsHeightWrapContent;
    field public boolean mIsWidthWrapContent;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor! mLeft;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor![]! mListAnchors;
    field public androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour![]! mListDimensionBehaviors;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget![]! mListNextMatchConstraintsWidget;
    field public int mMatchConstraintDefaultHeight;
    field public int mMatchConstraintDefaultWidth;
    field public int mMatchConstraintMaxHeight;
    field public int mMatchConstraintMaxWidth;
    field public int mMatchConstraintMinHeight;
    field public int mMatchConstraintMinWidth;
    field public float mMatchConstraintPercentHeight;
    field public float mMatchConstraintPercentWidth;
    field protected int mMinHeight;
    field protected int mMinWidth;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget![]! mNextChainWidget;
    field protected int mOffsetX;
    field protected int mOffsetY;
    field public androidx.constraintlayout.core.widgets.ConstraintWidget! mParent;
    field public int[]! mResolvedMatchConstraintDefault;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor! mRight;
    field public androidx.constraintlayout.core.widgets.ConstraintAnchor! mTop;
    field public int mVerticalResolution;
    field public androidx.constraintlayout.core.widgets.analyzer.VerticalWidgetRun! mVerticalRun;
    field public float[]! mWeight;
    field protected int mX;
    field protected int mY;
    field public boolean measured;
    field public androidx.constraintlayout.core.widgets.analyzer.WidgetRun![]! run;
    field public String! stringId;
    field public androidx.constraintlayout.core.widgets.analyzer.ChainRun! verticalChainRun;
    field public int verticalGroup;
  }

  public enum ConstraintWidget.DimensionBehaviour {
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour FIXED;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour MATCH_CONSTRAINT;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour MATCH_PARENT;
    enum_constant public static final androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour WRAP_CONTENT;
  }

  public class ConstraintWidgetContainer extends androidx.constraintlayout.core.widgets.WidgetContainer {
    ctor public ConstraintWidgetContainer();
    ctor public ConstraintWidgetContainer(int, int);
    ctor public ConstraintWidgetContainer(int, int, int, int);
    ctor public ConstraintWidgetContainer(String!, int, int);
    method public boolean addChildrenToSolver(androidx.constraintlayout.core.LinearSystem!);
    method public void addHorizontalWrapMaxVariable(androidx.constraintlayout.core.widgets.ConstraintAnchor!);
    method public void addHorizontalWrapMinVariable(androidx.constraintlayout.core.widgets.ConstraintAnchor!);
    method public void defineTerminalWidgets();
    method public boolean directMeasure(boolean);
    method public boolean directMeasureSetup(boolean);
    method public boolean directMeasureWithOrientation(boolean, int);
    method public void fillMetrics(androidx.constraintlayout.core.Metrics!);
    method public java.util.ArrayList<androidx.constraintlayout.core.widgets.Guideline!>! getHorizontalGuidelines();
    method public androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer! getMeasurer();
    method public int getOptimizationLevel();
    method public androidx.constraintlayout.core.LinearSystem! getSystem();
    method public java.util.ArrayList<androidx.constraintlayout.core.widgets.Guideline!>! getVerticalGuidelines();
    method public boolean handlesInternalConstraints();
    method public void invalidateGraph();
    method public void invalidateMeasures();
    method public boolean isHeightMeasuredTooSmall();
    method public boolean isRtl();
    method public boolean isWidthMeasuredTooSmall();
    method public static boolean measure(int, androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer!, androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measure!, int);
    method public long measure(int, int, int, int, int, int, int, int, int);
    method public boolean optimizeFor(int);
    method public void setMeasurer(androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer!);
    method public void setOptimizationLevel(int);
    method public void setPadding(int, int, int, int);
    method public void setPass(int);
    method public void setRtl(boolean);
    method public boolean updateChildrenFromSolver(androidx.constraintlayout.core.LinearSystem!, boolean[]!);
    method public void updateHierarchy();
    field public androidx.constraintlayout.core.widgets.analyzer.DependencyGraph! mDependencyGraph;
    field public boolean mGroupsWrapOptimized;
    field public int mHorizontalChainsSize;
    field public boolean mHorizontalWrapOptimized;
    field public androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measure! mMeasure;
    field protected androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer! mMeasurer;
    field public androidx.constraintlayout.core.Metrics! mMetrics;
    field public boolean mSkipSolver;
    field protected androidx.constraintlayout.core.LinearSystem! mSystem;
    field public int mVerticalChainsSize;
    field public boolean mVerticalWrapOptimized;
    field public int mWrapFixedHeight;
    field public int mWrapFixedWidth;
  }

  public class Flow extends androidx.constraintlayout.core.widgets.VirtualLayout {
    ctor public Flow();
    method public float getMaxElementsWrap();
    method public void setFirstHorizontalBias(float);
    method public void setFirstHorizontalStyle(int);
    method public void setFirstVerticalBias(float);
    method public void setFirstVerticalStyle(int);
    method public void setHorizontalAlign(int);
    method public void setHorizontalBias(float);
    method public void setHorizontalGap(int);
    method public void setHorizontalStyle(int);
    method public void setLastHorizontalBias(float);
    method public void setLastHorizontalStyle(int);
    method public void setLastVerticalBias(float);
    method public void setLastVerticalStyle(int);
    method public void setMaxElementsWrap(int);
    method public void setOrientation(int);
    method public void setVerticalAlign(int);
    method public void setVerticalBias(float);
    method public void setVerticalGap(int);
    method public void setVerticalStyle(int);
    method public void setWrapMode(int);
    field public static final int HORIZONTAL_ALIGN_CENTER = 2; // 0x2
    field public static final int HORIZONTAL_ALIGN_END = 1; // 0x1
    field public static final int HORIZONTAL_ALIGN_START = 0; // 0x0
    field public static final int VERTICAL_ALIGN_BASELINE = 3; // 0x3
    field public static final int VERTICAL_ALIGN_BOTTOM = 1; // 0x1
    field public static final int VERTICAL_ALIGN_CENTER = 2; // 0x2
    field public static final int VERTICAL_ALIGN_TOP = 0; // 0x0
    field public static final int WRAP_ALIGNED = 2; // 0x2
    field public static final int WRAP_CHAIN = 1; // 0x1
    field public static final int WRAP_CHAIN_NEW = 3; // 0x3
    field public static final int WRAP_NONE = 0; // 0x0
  }

  public class Guideline extends androidx.constraintlayout.core.widgets.ConstraintWidget {
    ctor public Guideline();
    method public void cyclePosition();
    method public androidx.constraintlayout.core.widgets.ConstraintAnchor! getAnchor();
    method public int getMinimumPosition();
    method public int getOrientation();
    method public int getRelativeBegin();
    method public int getRelativeBehaviour();
    method public int getRelativeEnd();
    method public float getRelativePercent();
    method public boolean isPercent();
    method public void setFinalValue(int);
    method public void setGuideBegin(int);
    method public void setGuideEnd(int);
    method public void setGuidePercent(float);
    method public void setGuidePercent(int);
    method public void setMinimumPosition(int);
    method public void setOrientation(int);
    field public static final int HORIZONTAL = 0; // 0x0
    field public static final int RELATIVE_BEGIN = 1; // 0x1
    field public static final int RELATIVE_END = 2; // 0x2
    field public static final int RELATIVE_PERCENT = 0; // 0x0
    field public static final int RELATIVE_UNKNOWN = -1; // 0xffffffff
    field public static final int VERTICAL = 1; // 0x1
    field protected boolean mGuidelineUseRtl;
    field protected int mRelativeBegin;
    field protected int mRelativeEnd;
    field protected float mRelativePercent;
  }

  public interface Helper {
    method public void add(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void removeAllIds();
    method public void updateConstraints(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!);
  }

  public class HelperWidget extends androidx.constraintlayout.core.widgets.ConstraintWidget implements androidx.constraintlayout.core.widgets.Helper {
    ctor public HelperWidget();
    method public void add(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void addDependents(java.util.ArrayList<androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!>!, int, androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!);
    method public int findGroupInDependents(int);
    method public void removeAllIds();
    method public void updateConstraints(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!);
    field public androidx.constraintlayout.core.widgets.ConstraintWidget![]! mWidgets;
    field public int mWidgetsCount;
  }

  public class Optimizer {
    ctor public Optimizer();
    method public static final boolean enabled(int, int);
    field public static final int OPTIMIZATION_BARRIER = 2; // 0x2
    field public static final int OPTIMIZATION_CACHE_MEASURES = 256; // 0x100
    field public static final int OPTIMIZATION_CHAIN = 4; // 0x4
    field public static final int OPTIMIZATION_DEPENDENCY_ORDERING = 512; // 0x200
    field public static final int OPTIMIZATION_DIMENSIONS = 8; // 0x8
    field public static final int OPTIMIZATION_DIRECT = 1; // 0x1
    field public static final int OPTIMIZATION_GRAPH = 64; // 0x40
    field public static final int OPTIMIZATION_GRAPH_WRAP = 128; // 0x80
    field public static final int OPTIMIZATION_GROUPING = 1024; // 0x400
    field public static final int OPTIMIZATION_GROUPS = 32; // 0x20
    field public static final int OPTIMIZATION_NONE = 0; // 0x0
    field public static final int OPTIMIZATION_RATIO = 16; // 0x10
    field public static final int OPTIMIZATION_STANDARD = 257; // 0x101
  }

  public class Placeholder extends androidx.constraintlayout.core.widgets.VirtualLayout {
    ctor public Placeholder();
  }

  public class Rectangle {
    ctor public Rectangle();
    method public boolean contains(int, int);
    method public int getCenterX();
    method public int getCenterY();
    method public void setBounds(int, int, int, int);
    field public int height;
    field public int width;
    field public int x;
    field public int y;
  }

  public class VirtualLayout extends androidx.constraintlayout.core.widgets.HelperWidget {
    ctor public VirtualLayout();
    method public void applyRtl(boolean);
    method public void captureWidgets();
    method public boolean contains(java.util.HashSet<androidx.constraintlayout.core.widgets.ConstraintWidget!>!);
    method public int getMeasuredHeight();
    method public int getMeasuredWidth();
    method public int getPaddingBottom();
    method public int getPaddingLeft();
    method public int getPaddingRight();
    method public int getPaddingTop();
    method protected void measure(androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!, int, androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!, int);
    method public void measure(int, int, int, int);
    method protected boolean measureChildren();
    method public boolean needSolverPass();
    method protected void needsCallbackFromSolver(boolean);
    method public void setMeasure(int, int);
    method public void setPadding(int);
    method public void setPaddingBottom(int);
    method public void setPaddingEnd(int);
    method public void setPaddingLeft(int);
    method public void setPaddingRight(int);
    method public void setPaddingStart(int);
    method public void setPaddingTop(int);
    field protected androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measure! mMeasure;
  }

  public class WidgetContainer extends androidx.constraintlayout.core.widgets.ConstraintWidget {
    ctor public WidgetContainer();
    ctor public WidgetContainer(int, int);
    ctor public WidgetContainer(int, int, int, int);
    method public void add(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void add(androidx.constraintlayout.core.widgets.ConstraintWidget!...);
    method public java.util.ArrayList<androidx.constraintlayout.core.widgets.ConstraintWidget!>! getChildren();
    method public androidx.constraintlayout.core.widgets.ConstraintWidgetContainer! getRootConstraintContainer();
    method public void layout();
    method public void remove(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void removeAllChildren();
    field public java.util.ArrayList<androidx.constraintlayout.core.widgets.ConstraintWidget!>! mChildren;
  }

}

package androidx.constraintlayout.core.widgets.analyzer {

  public class BasicMeasure {
    ctor public BasicMeasure(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!);
    method public long solverMeasure(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!, int, int, int, int, int, int, int, int, int);
    method public void updateHierarchy(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!);
    field public static final int AT_MOST = -2147483648; // 0x80000000
    field public static final int EXACTLY = 1073741824; // 0x40000000
    field public static final int FIXED = -3; // 0xfffffffd
    field public static final int MATCH_PARENT = -1; // 0xffffffff
    field public static final int UNSPECIFIED = 0; // 0x0
    field public static final int WRAP_CONTENT = -2; // 0xfffffffe
  }

  public static class BasicMeasure.Measure {
    ctor public BasicMeasure.Measure();
    field public static int SELF_DIMENSIONS;
    field public static int TRY_GIVEN_DIMENSIONS;
    field public static int USE_GIVEN_DIMENSIONS;
    field public androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour! horizontalBehavior;
    field public int horizontalDimension;
    field public int measureStrategy;
    field public int measuredBaseline;
    field public boolean measuredHasBaseline;
    field public int measuredHeight;
    field public boolean measuredNeedsSolverPass;
    field public int measuredWidth;
    field public androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour! verticalBehavior;
    field public int verticalDimension;
  }

  public static interface BasicMeasure.Measurer {
    method public void didMeasures();
    method public void measure(androidx.constraintlayout.core.widgets.ConstraintWidget!, androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measure!);
  }

  public class ChainRun extends androidx.constraintlayout.core.widgets.analyzer.WidgetRun {
    ctor public ChainRun(androidx.constraintlayout.core.widgets.ConstraintWidget!, int);
    method public void applyToWidget();
  }

  public interface Dependency {
    method public void update(androidx.constraintlayout.core.widgets.analyzer.Dependency!);
  }

  public class DependencyGraph {
    ctor public DependencyGraph(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!);
    method public void buildGraph();
    method public void buildGraph(java.util.ArrayList<androidx.constraintlayout.core.widgets.analyzer.WidgetRun!>!);
    method public void defineTerminalWidgets(androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!, androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!);
    method public boolean directMeasure(boolean);
    method public boolean directMeasureSetup(boolean);
    method public boolean directMeasureWithOrientation(boolean, int);
    method public void invalidateGraph();
    method public void invalidateMeasures();
    method public void measureWidgets();
    method public void setMeasurer(androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer!);
  }

  public class DependencyNode implements androidx.constraintlayout.core.widgets.analyzer.Dependency {
    ctor public DependencyNode(androidx.constraintlayout.core.widgets.analyzer.WidgetRun!);
    method public void addDependency(androidx.constraintlayout.core.widgets.analyzer.Dependency!);
    method public void clear();
    method public String! name();
    method public void resolve(int);
    method public void update(androidx.constraintlayout.core.widgets.analyzer.Dependency!);
    field public boolean delegateToWidgetRun;
    field public boolean readyToSolve;
    field public boolean resolved;
    field public androidx.constraintlayout.core.widgets.analyzer.Dependency! updateDelegate;
    field public int value;
  }

  public class Direct {
    ctor public Direct();
    method public static String! ls(int);
    method public static boolean solveChain(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!, androidx.constraintlayout.core.LinearSystem!, int, int, androidx.constraintlayout.core.widgets.ChainHead!, boolean, boolean, boolean);
    method public static void solvingPass(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!, androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer!);
  }

  public class Grouping {
    ctor public Grouping();
    method public static androidx.constraintlayout.core.widgets.analyzer.WidgetGroup! findDependents(androidx.constraintlayout.core.widgets.ConstraintWidget!, int, java.util.ArrayList<androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!>!, androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!);
    method public static boolean simpleSolvingPass(androidx.constraintlayout.core.widgets.ConstraintWidgetContainer!, androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer!);
    method public static boolean validInGroup(androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!, androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!, androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!, androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour!);
  }

  public class HorizontalWidgetRun extends androidx.constraintlayout.core.widgets.analyzer.WidgetRun {
    ctor public HorizontalWidgetRun(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void applyToWidget();
  }

  public class VerticalWidgetRun extends androidx.constraintlayout.core.widgets.analyzer.WidgetRun {
    ctor public VerticalWidgetRun(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void applyToWidget();
    field public androidx.constraintlayout.core.widgets.analyzer.DependencyNode! baseline;
  }

  public class WidgetGroup {
    ctor public WidgetGroup(int);
    method public boolean add(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method public void apply();
    method public void cleanup(java.util.ArrayList<androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!>!);
    method public void clear();
    method public int getId();
    method public int getOrientation();
    method public boolean intersectWith(androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!);
    method public boolean isAuthoritative();
    method public int measureWrap(androidx.constraintlayout.core.LinearSystem!, int);
    method public void moveTo(int, androidx.constraintlayout.core.widgets.analyzer.WidgetGroup!);
    method public void setAuthoritative(boolean);
    method public void setOrientation(int);
    method public int size();
  }

  public abstract class WidgetRun implements androidx.constraintlayout.core.widgets.analyzer.Dependency {
    ctor public WidgetRun(androidx.constraintlayout.core.widgets.ConstraintWidget!);
    method protected final void addTarget(androidx.constraintlayout.core.widgets.analyzer.DependencyNode!, androidx.constraintlayout.core.widgets.analyzer.DependencyNode!, int);
    method protected final void addTarget(androidx.constraintlayout.core.widgets.analyzer.DependencyNode!, androidx.constraintlayout.core.widgets.analyzer.DependencyNode!, int, androidx.constraintlayout.core.widgets.analyzer.DimensionDependency!);
    method protected final int getLimitedDimension(int, int);
    method protected final androidx.constraintlayout.core.widgets.analyzer.DependencyNode! getTarget(androidx.constraintlayout.core.widgets.ConstraintAnchor!);
    method protected final androidx.constraintlayout.core.widgets.analyzer.DependencyNode! getTarget(androidx.constraintlayout.core.widgets.ConstraintAnchor!, int);
    method public long getWrapDimension();
    method public boolean isCenterConnection();
    method public boolean isDimensionResolved();
    method public boolean isResolved();
    method public void update(androidx.constraintlayout.core.widgets.analyzer.Dependency!);
    method protected void updateRunCenter(androidx.constraintlayout.core.widgets.analyzer.Dependency!, androidx.constraintlayout.core.widgets.ConstraintAnchor!, androidx.constraintlayout.core.widgets.ConstraintAnchor!, int);
    method protected void updateRunEnd(androidx.constraintlayout.core.widgets.analyzer.Dependency!);
    method protected void updateRunStart(androidx.constraintlayout.core.widgets.analyzer.Dependency!);
    method public long wrapSize(int);
    field public androidx.constraintlayout.core.widgets.analyzer.DependencyNode! end;
    field protected androidx.constraintlayout.core.widgets.ConstraintWidget.DimensionBehaviour! mDimensionBehavior;
    field protected androidx.constraintlayout.core.widgets.analyzer.WidgetRun.RunType! mRunType;
    field public int matchConstraintsType;
    field public int orientation;
    field public androidx.constraintlayout.core.widgets.analyzer.DependencyNode! start;
  }

}

