tests/location/location_gnss/src/android/location/cts/gnss/asn1/supl2/rrlp_components/UncompressedEphemeris.java

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.location.cts.asn1.supl2.rrlp_components;

/*
 */


//
//
import android.location.cts.asn1.base.Asn1Integer;
import android.location.cts.asn1.base.Asn1Null;
import android.location.cts.asn1.base.Asn1Object;
import android.location.cts.asn1.base.Asn1Sequence;
import android.location.cts.asn1.base.Asn1Tag;
import android.location.cts.asn1.base.BitStream;
import android.location.cts.asn1.base.BitStreamReader;
import android.location.cts.asn1.base.SequenceComponent;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import javax.annotation.Nullable;


/**
*/
public  class UncompressedEphemeris extends Asn1Sequence {
  //

  private static final Asn1Tag TAG_UncompressedEphemeris
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public UncompressedEphemeris() {
    super();
  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_UncompressedEphemeris;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_UncompressedEphemeris != null) {
      return ImmutableList.of(TAG_UncompressedEphemeris);
    } else {
      return Asn1Sequence.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new UncompressedEphemeris from encoded stream.
   */
  public static UncompressedEphemeris fromPerUnaligned(byte[] encodedBytes) {
    UncompressedEphemeris result = new UncompressedEphemeris();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new UncompressedEphemeris from encoded stream.
   */
  public static UncompressedEphemeris fromPerAligned(byte[] encodedBytes) {
    UncompressedEphemeris result = new UncompressedEphemeris();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }



  @Override protected boolean isExtensible() {
    return false;
  }

  @Override public boolean containsExtensionValues() {
    for (SequenceComponent extensionComponent : getExtensionComponents()) {
      if (extensionComponent.isExplicitlySet()) return true;
    }
    return false;
  }

  
  private UncompressedEphemeris.ephemCodeOnL2Type ephemCodeOnL2_;
  public UncompressedEphemeris.ephemCodeOnL2Type getEphemCodeOnL2() {
    return ephemCodeOnL2_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCodeOnL2Type
   */
  public void setEphemCodeOnL2(Asn1Object value) {
    this.ephemCodeOnL2_ = (UncompressedEphemeris.ephemCodeOnL2Type) value;
  }
  public UncompressedEphemeris.ephemCodeOnL2Type setEphemCodeOnL2ToNewInstance() {
    ephemCodeOnL2_ = new UncompressedEphemeris.ephemCodeOnL2Type();
    return ephemCodeOnL2_;
  }
  
  private UncompressedEphemeris.ephemURAType ephemURA_;
  public UncompressedEphemeris.ephemURAType getEphemURA() {
    return ephemURA_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemURAType
   */
  public void setEphemURA(Asn1Object value) {
    this.ephemURA_ = (UncompressedEphemeris.ephemURAType) value;
  }
  public UncompressedEphemeris.ephemURAType setEphemURAToNewInstance() {
    ephemURA_ = new UncompressedEphemeris.ephemURAType();
    return ephemURA_;
  }
  
  private UncompressedEphemeris.ephemSVhealthType ephemSVhealth_;
  public UncompressedEphemeris.ephemSVhealthType getEphemSVhealth() {
    return ephemSVhealth_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemSVhealthType
   */
  public void setEphemSVhealth(Asn1Object value) {
    this.ephemSVhealth_ = (UncompressedEphemeris.ephemSVhealthType) value;
  }
  public UncompressedEphemeris.ephemSVhealthType setEphemSVhealthToNewInstance() {
    ephemSVhealth_ = new UncompressedEphemeris.ephemSVhealthType();
    return ephemSVhealth_;
  }
  
  private UncompressedEphemeris.ephemIODCType ephemIODC_;
  public UncompressedEphemeris.ephemIODCType getEphemIODC() {
    return ephemIODC_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemIODCType
   */
  public void setEphemIODC(Asn1Object value) {
    this.ephemIODC_ = (UncompressedEphemeris.ephemIODCType) value;
  }
  public UncompressedEphemeris.ephemIODCType setEphemIODCToNewInstance() {
    ephemIODC_ = new UncompressedEphemeris.ephemIODCType();
    return ephemIODC_;
  }
  
  private UncompressedEphemeris.ephemL2PflagType ephemL2Pflag_;
  public UncompressedEphemeris.ephemL2PflagType getEphemL2Pflag() {
    return ephemL2Pflag_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemL2PflagType
   */
  public void setEphemL2Pflag(Asn1Object value) {
    this.ephemL2Pflag_ = (UncompressedEphemeris.ephemL2PflagType) value;
  }
  public UncompressedEphemeris.ephemL2PflagType setEphemL2PflagToNewInstance() {
    ephemL2Pflag_ = new UncompressedEphemeris.ephemL2PflagType();
    return ephemL2Pflag_;
  }
  
  private EphemerisSubframe1Reserved ephemSF1Rsvd_;
  public EphemerisSubframe1Reserved getEphemSF1Rsvd() {
    return ephemSF1Rsvd_;
  }
  /**
   * @throws ClassCastException if value is not a EphemerisSubframe1Reserved
   */
  public void setEphemSF1Rsvd(Asn1Object value) {
    this.ephemSF1Rsvd_ = (EphemerisSubframe1Reserved) value;
  }
  public EphemerisSubframe1Reserved setEphemSF1RsvdToNewInstance() {
    ephemSF1Rsvd_ = new EphemerisSubframe1Reserved();
    return ephemSF1Rsvd_;
  }
  
  private UncompressedEphemeris.ephemTgdType ephemTgd_;
  public UncompressedEphemeris.ephemTgdType getEphemTgd() {
    return ephemTgd_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemTgdType
   */
  public void setEphemTgd(Asn1Object value) {
    this.ephemTgd_ = (UncompressedEphemeris.ephemTgdType) value;
  }
  public UncompressedEphemeris.ephemTgdType setEphemTgdToNewInstance() {
    ephemTgd_ = new UncompressedEphemeris.ephemTgdType();
    return ephemTgd_;
  }
  
  private UncompressedEphemeris.ephemTocType ephemToc_;
  public UncompressedEphemeris.ephemTocType getEphemToc() {
    return ephemToc_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemTocType
   */
  public void setEphemToc(Asn1Object value) {
    this.ephemToc_ = (UncompressedEphemeris.ephemTocType) value;
  }
  public UncompressedEphemeris.ephemTocType setEphemTocToNewInstance() {
    ephemToc_ = new UncompressedEphemeris.ephemTocType();
    return ephemToc_;
  }
  
  private UncompressedEphemeris.ephemAF2Type ephemAF2_;
  public UncompressedEphemeris.ephemAF2Type getEphemAF2() {
    return ephemAF2_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAF2Type
   */
  public void setEphemAF2(Asn1Object value) {
    this.ephemAF2_ = (UncompressedEphemeris.ephemAF2Type) value;
  }
  public UncompressedEphemeris.ephemAF2Type setEphemAF2ToNewInstance() {
    ephemAF2_ = new UncompressedEphemeris.ephemAF2Type();
    return ephemAF2_;
  }
  
  private UncompressedEphemeris.ephemAF1Type ephemAF1_;
  public UncompressedEphemeris.ephemAF1Type getEphemAF1() {
    return ephemAF1_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAF1Type
   */
  public void setEphemAF1(Asn1Object value) {
    this.ephemAF1_ = (UncompressedEphemeris.ephemAF1Type) value;
  }
  public UncompressedEphemeris.ephemAF1Type setEphemAF1ToNewInstance() {
    ephemAF1_ = new UncompressedEphemeris.ephemAF1Type();
    return ephemAF1_;
  }
  
  private UncompressedEphemeris.ephemAF0Type ephemAF0_;
  public UncompressedEphemeris.ephemAF0Type getEphemAF0() {
    return ephemAF0_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAF0Type
   */
  public void setEphemAF0(Asn1Object value) {
    this.ephemAF0_ = (UncompressedEphemeris.ephemAF0Type) value;
  }
  public UncompressedEphemeris.ephemAF0Type setEphemAF0ToNewInstance() {
    ephemAF0_ = new UncompressedEphemeris.ephemAF0Type();
    return ephemAF0_;
  }
  
  private UncompressedEphemeris.ephemCrsType ephemCrs_;
  public UncompressedEphemeris.ephemCrsType getEphemCrs() {
    return ephemCrs_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCrsType
   */
  public void setEphemCrs(Asn1Object value) {
    this.ephemCrs_ = (UncompressedEphemeris.ephemCrsType) value;
  }
  public UncompressedEphemeris.ephemCrsType setEphemCrsToNewInstance() {
    ephemCrs_ = new UncompressedEphemeris.ephemCrsType();
    return ephemCrs_;
  }
  
  private UncompressedEphemeris.ephemDeltaNType ephemDeltaN_;
  public UncompressedEphemeris.ephemDeltaNType getEphemDeltaN() {
    return ephemDeltaN_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemDeltaNType
   */
  public void setEphemDeltaN(Asn1Object value) {
    this.ephemDeltaN_ = (UncompressedEphemeris.ephemDeltaNType) value;
  }
  public UncompressedEphemeris.ephemDeltaNType setEphemDeltaNToNewInstance() {
    ephemDeltaN_ = new UncompressedEphemeris.ephemDeltaNType();
    return ephemDeltaN_;
  }
  
  private UncompressedEphemeris.ephemM0Type ephemM0_;
  public UncompressedEphemeris.ephemM0Type getEphemM0() {
    return ephemM0_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemM0Type
   */
  public void setEphemM0(Asn1Object value) {
    this.ephemM0_ = (UncompressedEphemeris.ephemM0Type) value;
  }
  public UncompressedEphemeris.ephemM0Type setEphemM0ToNewInstance() {
    ephemM0_ = new UncompressedEphemeris.ephemM0Type();
    return ephemM0_;
  }
  
  private UncompressedEphemeris.ephemCucType ephemCuc_;
  public UncompressedEphemeris.ephemCucType getEphemCuc() {
    return ephemCuc_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCucType
   */
  public void setEphemCuc(Asn1Object value) {
    this.ephemCuc_ = (UncompressedEphemeris.ephemCucType) value;
  }
  public UncompressedEphemeris.ephemCucType setEphemCucToNewInstance() {
    ephemCuc_ = new UncompressedEphemeris.ephemCucType();
    return ephemCuc_;
  }
  
  private UncompressedEphemeris.ephemEType ephemE_;
  public UncompressedEphemeris.ephemEType getEphemE() {
    return ephemE_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemEType
   */
  public void setEphemE(Asn1Object value) {
    this.ephemE_ = (UncompressedEphemeris.ephemEType) value;
  }
  public UncompressedEphemeris.ephemEType setEphemEToNewInstance() {
    ephemE_ = new UncompressedEphemeris.ephemEType();
    return ephemE_;
  }
  
  private UncompressedEphemeris.ephemCusType ephemCus_;
  public UncompressedEphemeris.ephemCusType getEphemCus() {
    return ephemCus_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCusType
   */
  public void setEphemCus(Asn1Object value) {
    this.ephemCus_ = (UncompressedEphemeris.ephemCusType) value;
  }
  public UncompressedEphemeris.ephemCusType setEphemCusToNewInstance() {
    ephemCus_ = new UncompressedEphemeris.ephemCusType();
    return ephemCus_;
  }
  
  private UncompressedEphemeris.ephemAPowerHalfType ephemAPowerHalf_;
  public UncompressedEphemeris.ephemAPowerHalfType getEphemAPowerHalf() {
    return ephemAPowerHalf_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAPowerHalfType
   */
  public void setEphemAPowerHalf(Asn1Object value) {
    this.ephemAPowerHalf_ = (UncompressedEphemeris.ephemAPowerHalfType) value;
  }
  public UncompressedEphemeris.ephemAPowerHalfType setEphemAPowerHalfToNewInstance() {
    ephemAPowerHalf_ = new UncompressedEphemeris.ephemAPowerHalfType();
    return ephemAPowerHalf_;
  }
  
  private UncompressedEphemeris.ephemToeType ephemToe_;
  public UncompressedEphemeris.ephemToeType getEphemToe() {
    return ephemToe_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemToeType
   */
  public void setEphemToe(Asn1Object value) {
    this.ephemToe_ = (UncompressedEphemeris.ephemToeType) value;
  }
  public UncompressedEphemeris.ephemToeType setEphemToeToNewInstance() {
    ephemToe_ = new UncompressedEphemeris.ephemToeType();
    return ephemToe_;
  }
  
  private UncompressedEphemeris.ephemFitFlagType ephemFitFlag_;
  public UncompressedEphemeris.ephemFitFlagType getEphemFitFlag() {
    return ephemFitFlag_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemFitFlagType
   */
  public void setEphemFitFlag(Asn1Object value) {
    this.ephemFitFlag_ = (UncompressedEphemeris.ephemFitFlagType) value;
  }
  public UncompressedEphemeris.ephemFitFlagType setEphemFitFlagToNewInstance() {
    ephemFitFlag_ = new UncompressedEphemeris.ephemFitFlagType();
    return ephemFitFlag_;
  }
  
  private UncompressedEphemeris.ephemAODAType ephemAODA_;
  public UncompressedEphemeris.ephemAODAType getEphemAODA() {
    return ephemAODA_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAODAType
   */
  public void setEphemAODA(Asn1Object value) {
    this.ephemAODA_ = (UncompressedEphemeris.ephemAODAType) value;
  }
  public UncompressedEphemeris.ephemAODAType setEphemAODAToNewInstance() {
    ephemAODA_ = new UncompressedEphemeris.ephemAODAType();
    return ephemAODA_;
  }
  
  private UncompressedEphemeris.ephemCicType ephemCic_;
  public UncompressedEphemeris.ephemCicType getEphemCic() {
    return ephemCic_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCicType
   */
  public void setEphemCic(Asn1Object value) {
    this.ephemCic_ = (UncompressedEphemeris.ephemCicType) value;
  }
  public UncompressedEphemeris.ephemCicType setEphemCicToNewInstance() {
    ephemCic_ = new UncompressedEphemeris.ephemCicType();
    return ephemCic_;
  }
  
  private UncompressedEphemeris.ephemOmegaA0Type ephemOmegaA0_;
  public UncompressedEphemeris.ephemOmegaA0Type getEphemOmegaA0() {
    return ephemOmegaA0_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemOmegaA0Type
   */
  public void setEphemOmegaA0(Asn1Object value) {
    this.ephemOmegaA0_ = (UncompressedEphemeris.ephemOmegaA0Type) value;
  }
  public UncompressedEphemeris.ephemOmegaA0Type setEphemOmegaA0ToNewInstance() {
    ephemOmegaA0_ = new UncompressedEphemeris.ephemOmegaA0Type();
    return ephemOmegaA0_;
  }
  
  private UncompressedEphemeris.ephemCisType ephemCis_;
  public UncompressedEphemeris.ephemCisType getEphemCis() {
    return ephemCis_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCisType
   */
  public void setEphemCis(Asn1Object value) {
    this.ephemCis_ = (UncompressedEphemeris.ephemCisType) value;
  }
  public UncompressedEphemeris.ephemCisType setEphemCisToNewInstance() {
    ephemCis_ = new UncompressedEphemeris.ephemCisType();
    return ephemCis_;
  }
  
  private UncompressedEphemeris.ephemI0Type ephemI0_;
  public UncompressedEphemeris.ephemI0Type getEphemI0() {
    return ephemI0_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemI0Type
   */
  public void setEphemI0(Asn1Object value) {
    this.ephemI0_ = (UncompressedEphemeris.ephemI0Type) value;
  }
  public UncompressedEphemeris.ephemI0Type setEphemI0ToNewInstance() {
    ephemI0_ = new UncompressedEphemeris.ephemI0Type();
    return ephemI0_;
  }
  
  private UncompressedEphemeris.ephemCrcType ephemCrc_;
  public UncompressedEphemeris.ephemCrcType getEphemCrc() {
    return ephemCrc_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCrcType
   */
  public void setEphemCrc(Asn1Object value) {
    this.ephemCrc_ = (UncompressedEphemeris.ephemCrcType) value;
  }
  public UncompressedEphemeris.ephemCrcType setEphemCrcToNewInstance() {
    ephemCrc_ = new UncompressedEphemeris.ephemCrcType();
    return ephemCrc_;
  }
  
  private UncompressedEphemeris.ephemWType ephemW_;
  public UncompressedEphemeris.ephemWType getEphemW() {
    return ephemW_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemWType
   */
  public void setEphemW(Asn1Object value) {
    this.ephemW_ = (UncompressedEphemeris.ephemWType) value;
  }
  public UncompressedEphemeris.ephemWType setEphemWToNewInstance() {
    ephemW_ = new UncompressedEphemeris.ephemWType();
    return ephemW_;
  }
  
  private UncompressedEphemeris.ephemOmegaADotType ephemOmegaADot_;
  public UncompressedEphemeris.ephemOmegaADotType getEphemOmegaADot() {
    return ephemOmegaADot_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemOmegaADotType
   */
  public void setEphemOmegaADot(Asn1Object value) {
    this.ephemOmegaADot_ = (UncompressedEphemeris.ephemOmegaADotType) value;
  }
  public UncompressedEphemeris.ephemOmegaADotType setEphemOmegaADotToNewInstance() {
    ephemOmegaADot_ = new UncompressedEphemeris.ephemOmegaADotType();
    return ephemOmegaADot_;
  }
  
  private UncompressedEphemeris.ephemIDotType ephemIDot_;
  public UncompressedEphemeris.ephemIDotType getEphemIDot() {
    return ephemIDot_;
  }
  /**
   * @throws ClassCastException if value is not a UncompressedEphemeris.ephemIDotType
   */
  public void setEphemIDot(Asn1Object value) {
    this.ephemIDot_ = (UncompressedEphemeris.ephemIDotType) value;
  }
  public UncompressedEphemeris.ephemIDotType setEphemIDotToNewInstance() {
    ephemIDot_ = new UncompressedEphemeris.ephemIDotType();
    return ephemIDot_;
  }
  

  

  

  @Override public Iterable<? extends SequenceComponent> getComponents() {
    ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);

          @Override public boolean isExplicitlySet() {
            return getEphemCodeOnL2() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemCodeOnL2();
          }

          @Override public void setToNewInstance() {
            setEphemCodeOnL2ToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemCodeOnL2Type.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemCodeOnL2 : "
                    + getEphemCodeOnL2().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);

          @Override public boolean isExplicitlySet() {
            return getEphemURA() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemURA();
          }

          @Override public void setToNewInstance() {
            setEphemURAToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemURAType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemURA : "
                    + getEphemURA().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);

          @Override public boolean isExplicitlySet() {
            return getEphemSVhealth() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemSVhealth();
          }

          @Override public void setToNewInstance() {
            setEphemSVhealthToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemSVhealthType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemSVhealth : "
                    + getEphemSVhealth().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);

          @Override public boolean isExplicitlySet() {
            return getEphemIODC() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemIODC();
          }

          @Override public void setToNewInstance() {
            setEphemIODCToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemIODCType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemIODC : "
                    + getEphemIODC().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);

          @Override public boolean isExplicitlySet() {
            return getEphemL2Pflag() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemL2Pflag();
          }

          @Override public void setToNewInstance() {
            setEphemL2PflagToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemL2PflagType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemL2Pflag : "
                    + getEphemL2Pflag().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);

          @Override public boolean isExplicitlySet() {
            return getEphemSF1Rsvd() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemSF1Rsvd();
          }

          @Override public void setToNewInstance() {
            setEphemSF1RsvdToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? EphemerisSubframe1Reserved.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemSF1Rsvd : "
                    + getEphemSF1Rsvd().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);

          @Override public boolean isExplicitlySet() {
            return getEphemTgd() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemTgd();
          }

          @Override public void setToNewInstance() {
            setEphemTgdToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemTgdType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemTgd : "
                    + getEphemTgd().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);

          @Override public boolean isExplicitlySet() {
            return getEphemToc() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemToc();
          }

          @Override public void setToNewInstance() {
            setEphemTocToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemTocType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemToc : "
                    + getEphemToc().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);

          @Override public boolean isExplicitlySet() {
            return getEphemAF2() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemAF2();
          }

          @Override public void setToNewInstance() {
            setEphemAF2ToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemAF2Type.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemAF2 : "
                    + getEphemAF2().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);

          @Override public boolean isExplicitlySet() {
            return getEphemAF1() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemAF1();
          }

          @Override public void setToNewInstance() {
            setEphemAF1ToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemAF1Type.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemAF1 : "
                    + getEphemAF1().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);

          @Override public boolean isExplicitlySet() {
            return getEphemAF0() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemAF0();
          }

          @Override public void setToNewInstance() {
            setEphemAF0ToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemAF0Type.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemAF0 : "
                    + getEphemAF0().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);

          @Override public boolean isExplicitlySet() {
            return getEphemCrs() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemCrs();
          }

          @Override public void setToNewInstance() {
            setEphemCrsToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemCrsType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemCrs : "
                    + getEphemCrs().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);

          @Override public boolean isExplicitlySet() {
            return getEphemDeltaN() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemDeltaN();
          }

          @Override public void setToNewInstance() {
            setEphemDeltaNToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemDeltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemDeltaN : "
                    + getEphemDeltaN().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);

          @Override public boolean isExplicitlySet() {
            return getEphemM0() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemM0();
          }

          @Override public void setToNewInstance() {
            setEphemM0ToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemM0Type.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemM0 : "
                    + getEphemM0().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);

          @Override public boolean isExplicitlySet() {
            return getEphemCuc() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemCuc();
          }

          @Override public void setToNewInstance() {
            setEphemCucToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemCucType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemCuc : "
                    + getEphemCuc().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);

          @Override public boolean isExplicitlySet() {
            return getEphemE() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemE();
          }

          @Override public void setToNewInstance() {
            setEphemEToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemEType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemE : "
                    + getEphemE().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 16);

          @Override public boolean isExplicitlySet() {
            return getEphemCus() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemCus();
          }

          @Override public void setToNewInstance() {
            setEphemCusToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemCusType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemCus : "
                    + getEphemCus().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 17);

          @Override public boolean isExplicitlySet() {
            return getEphemAPowerHalf() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemAPowerHalf();
          }

          @Override public void setToNewInstance() {
            setEphemAPowerHalfToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemAPowerHalf : "
                    + getEphemAPowerHalf().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 18);

          @Override public boolean isExplicitlySet() {
            return getEphemToe() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemToe();
          }

          @Override public void setToNewInstance() {
            setEphemToeToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemToeType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemToe : "
                    + getEphemToe().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 19);

          @Override public boolean isExplicitlySet() {
            return getEphemFitFlag() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemFitFlag();
          }

          @Override public void setToNewInstance() {
            setEphemFitFlagToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemFitFlagType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemFitFlag : "
                    + getEphemFitFlag().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 20);

          @Override public boolean isExplicitlySet() {
            return getEphemAODA() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemAODA();
          }

          @Override public void setToNewInstance() {
            setEphemAODAToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemAODAType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemAODA : "
                    + getEphemAODA().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 21);

          @Override public boolean isExplicitlySet() {
            return getEphemCic() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemCic();
          }

          @Override public void setToNewInstance() {
            setEphemCicToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemCicType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemCic : "
                    + getEphemCic().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 22);

          @Override public boolean isExplicitlySet() {
            return getEphemOmegaA0() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemOmegaA0();
          }

          @Override public void setToNewInstance() {
            setEphemOmegaA0ToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemOmegaA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemOmegaA0 : "
                    + getEphemOmegaA0().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 23);

          @Override public boolean isExplicitlySet() {
            return getEphemCis() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemCis();
          }

          @Override public void setToNewInstance() {
            setEphemCisToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemCisType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemCis : "
                    + getEphemCis().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 24);

          @Override public boolean isExplicitlySet() {
            return getEphemI0() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemI0();
          }

          @Override public void setToNewInstance() {
            setEphemI0ToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemI0Type.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemI0 : "
                    + getEphemI0().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 25);

          @Override public boolean isExplicitlySet() {
            return getEphemCrc() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemCrc();
          }

          @Override public void setToNewInstance() {
            setEphemCrcToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemCrcType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemCrc : "
                    + getEphemCrc().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 26);

          @Override public boolean isExplicitlySet() {
            return getEphemW() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemW();
          }

          @Override public void setToNewInstance() {
            setEphemWToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemWType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemW : "
                    + getEphemW().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 27);

          @Override public boolean isExplicitlySet() {
            return getEphemOmegaADot() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemOmegaADot();
          }

          @Override public void setToNewInstance() {
            setEphemOmegaADotToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemOmegaADotType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemOmegaADot : "
                    + getEphemOmegaADot().toIndentedString(indent);
              }
        });
    
    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 28);

          @Override public boolean isExplicitlySet() {
            return getEphemIDot() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

          @Override public boolean isOptional() {
            return false;
          }

          @Override public Asn1Object getComponentValue() {
            return getEphemIDot();
          }

          @Override public void setToNewInstance() {
            setEphemIDotToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? UncompressedEphemeris.ephemIDotType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

          @Override
          public boolean isImplicitTagging() {
            return true;
          }

          @Override public String toIndentedString(String indent) {
                return "ephemIDot : "
                    + getEphemIDot().toIndentedString(indent);
              }
        });
    
    return builder.build();
  }

  @Override public Iterable<? extends SequenceComponent>
                                                    getExtensionComponents() {
    ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
      
      return builder.build();
    }

  
/*
 */


//

/**
 */
public static class ephemCodeOnL2Type extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemCodeOnL2Type
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemCodeOnL2Type() {
    super();
    setValueRange("0", "3");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemCodeOnL2Type;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemCodeOnL2Type != null) {
      return ImmutableList.of(TAG_ephemCodeOnL2Type);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemCodeOnL2Type from encoded stream.
   */
  public static ephemCodeOnL2Type fromPerUnaligned(byte[] encodedBytes) {
    ephemCodeOnL2Type result = new ephemCodeOnL2Type();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemCodeOnL2Type from encoded stream.
   */
  public static ephemCodeOnL2Type fromPerAligned(byte[] encodedBytes) {
    ephemCodeOnL2Type result = new ephemCodeOnL2Type();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemCodeOnL2Type = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemURAType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemURAType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemURAType() {
    super();
    setValueRange("0", "15");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemURAType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemURAType != null) {
      return ImmutableList.of(TAG_ephemURAType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemURAType from encoded stream.
   */
  public static ephemURAType fromPerUnaligned(byte[] encodedBytes) {
    ephemURAType result = new ephemURAType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemURAType from encoded stream.
   */
  public static ephemURAType fromPerAligned(byte[] encodedBytes) {
    ephemURAType result = new ephemURAType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemURAType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemSVhealthType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemSVhealthType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemSVhealthType() {
    super();
    setValueRange("0", "63");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemSVhealthType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemSVhealthType != null) {
      return ImmutableList.of(TAG_ephemSVhealthType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemSVhealthType from encoded stream.
   */
  public static ephemSVhealthType fromPerUnaligned(byte[] encodedBytes) {
    ephemSVhealthType result = new ephemSVhealthType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemSVhealthType from encoded stream.
   */
  public static ephemSVhealthType fromPerAligned(byte[] encodedBytes) {
    ephemSVhealthType result = new ephemSVhealthType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemSVhealthType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemIODCType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemIODCType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemIODCType() {
    super();
    setValueRange("0", "1023");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemIODCType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemIODCType != null) {
      return ImmutableList.of(TAG_ephemIODCType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemIODCType from encoded stream.
   */
  public static ephemIODCType fromPerUnaligned(byte[] encodedBytes) {
    ephemIODCType result = new ephemIODCType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemIODCType from encoded stream.
   */
  public static ephemIODCType fromPerAligned(byte[] encodedBytes) {
    ephemIODCType result = new ephemIODCType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemIODCType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemL2PflagType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemL2PflagType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemL2PflagType() {
    super();
    setValueRange("0", "1");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemL2PflagType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemL2PflagType != null) {
      return ImmutableList.of(TAG_ephemL2PflagType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemL2PflagType from encoded stream.
   */
  public static ephemL2PflagType fromPerUnaligned(byte[] encodedBytes) {
    ephemL2PflagType result = new ephemL2PflagType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemL2PflagType from encoded stream.
   */
  public static ephemL2PflagType fromPerAligned(byte[] encodedBytes) {
    ephemL2PflagType result = new ephemL2PflagType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemL2PflagType = " + getInteger() + ";\n";
  }
}

  
  
  
/*
 */


//

/**
 */
public static class ephemTgdType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemTgdType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemTgdType() {
    super();
    setValueRange("-128", "127");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemTgdType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemTgdType != null) {
      return ImmutableList.of(TAG_ephemTgdType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemTgdType from encoded stream.
   */
  public static ephemTgdType fromPerUnaligned(byte[] encodedBytes) {
    ephemTgdType result = new ephemTgdType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemTgdType from encoded stream.
   */
  public static ephemTgdType fromPerAligned(byte[] encodedBytes) {
    ephemTgdType result = new ephemTgdType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemTgdType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemTocType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemTocType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemTocType() {
    super();
    setValueRange("0", "37799");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemTocType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemTocType != null) {
      return ImmutableList.of(TAG_ephemTocType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemTocType from encoded stream.
   */
  public static ephemTocType fromPerUnaligned(byte[] encodedBytes) {
    ephemTocType result = new ephemTocType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemTocType from encoded stream.
   */
  public static ephemTocType fromPerAligned(byte[] encodedBytes) {
    ephemTocType result = new ephemTocType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemTocType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemAF2Type extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemAF2Type
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemAF2Type() {
    super();
    setValueRange("-128", "127");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemAF2Type;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemAF2Type != null) {
      return ImmutableList.of(TAG_ephemAF2Type);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemAF2Type from encoded stream.
   */
  public static ephemAF2Type fromPerUnaligned(byte[] encodedBytes) {
    ephemAF2Type result = new ephemAF2Type();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemAF2Type from encoded stream.
   */
  public static ephemAF2Type fromPerAligned(byte[] encodedBytes) {
    ephemAF2Type result = new ephemAF2Type();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemAF2Type = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemAF1Type extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemAF1Type
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemAF1Type() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemAF1Type;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemAF1Type != null) {
      return ImmutableList.of(TAG_ephemAF1Type);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemAF1Type from encoded stream.
   */
  public static ephemAF1Type fromPerUnaligned(byte[] encodedBytes) {
    ephemAF1Type result = new ephemAF1Type();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemAF1Type from encoded stream.
   */
  public static ephemAF1Type fromPerAligned(byte[] encodedBytes) {
    ephemAF1Type result = new ephemAF1Type();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemAF1Type = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemAF0Type extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemAF0Type
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemAF0Type() {
    super();
    setValueRange("-2097152", "2097151");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemAF0Type;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemAF0Type != null) {
      return ImmutableList.of(TAG_ephemAF0Type);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemAF0Type from encoded stream.
   */
  public static ephemAF0Type fromPerUnaligned(byte[] encodedBytes) {
    ephemAF0Type result = new ephemAF0Type();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemAF0Type from encoded stream.
   */
  public static ephemAF0Type fromPerAligned(byte[] encodedBytes) {
    ephemAF0Type result = new ephemAF0Type();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemAF0Type = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemCrsType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemCrsType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemCrsType() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemCrsType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemCrsType != null) {
      return ImmutableList.of(TAG_ephemCrsType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemCrsType from encoded stream.
   */
  public static ephemCrsType fromPerUnaligned(byte[] encodedBytes) {
    ephemCrsType result = new ephemCrsType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemCrsType from encoded stream.
   */
  public static ephemCrsType fromPerAligned(byte[] encodedBytes) {
    ephemCrsType result = new ephemCrsType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemCrsType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemDeltaNType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemDeltaNType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemDeltaNType() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemDeltaNType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemDeltaNType != null) {
      return ImmutableList.of(TAG_ephemDeltaNType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemDeltaNType from encoded stream.
   */
  public static ephemDeltaNType fromPerUnaligned(byte[] encodedBytes) {
    ephemDeltaNType result = new ephemDeltaNType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemDeltaNType from encoded stream.
   */
  public static ephemDeltaNType fromPerAligned(byte[] encodedBytes) {
    ephemDeltaNType result = new ephemDeltaNType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemDeltaNType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemM0Type extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemM0Type
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemM0Type() {
    super();
    setValueRange("-2147483648", "2147483647");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemM0Type;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemM0Type != null) {
      return ImmutableList.of(TAG_ephemM0Type);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemM0Type from encoded stream.
   */
  public static ephemM0Type fromPerUnaligned(byte[] encodedBytes) {
    ephemM0Type result = new ephemM0Type();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemM0Type from encoded stream.
   */
  public static ephemM0Type fromPerAligned(byte[] encodedBytes) {
    ephemM0Type result = new ephemM0Type();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemM0Type = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemCucType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemCucType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemCucType() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemCucType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemCucType != null) {
      return ImmutableList.of(TAG_ephemCucType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemCucType from encoded stream.
   */
  public static ephemCucType fromPerUnaligned(byte[] encodedBytes) {
    ephemCucType result = new ephemCucType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemCucType from encoded stream.
   */
  public static ephemCucType fromPerAligned(byte[] encodedBytes) {
    ephemCucType result = new ephemCucType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemCucType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemEType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemEType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemEType() {
    super();
    setValueRange("0", "4294967295");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemEType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemEType != null) {
      return ImmutableList.of(TAG_ephemEType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemEType from encoded stream.
   */
  public static ephemEType fromPerUnaligned(byte[] encodedBytes) {
    ephemEType result = new ephemEType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemEType from encoded stream.
   */
  public static ephemEType fromPerAligned(byte[] encodedBytes) {
    ephemEType result = new ephemEType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemEType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemCusType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemCusType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemCusType() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemCusType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemCusType != null) {
      return ImmutableList.of(TAG_ephemCusType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemCusType from encoded stream.
   */
  public static ephemCusType fromPerUnaligned(byte[] encodedBytes) {
    ephemCusType result = new ephemCusType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemCusType from encoded stream.
   */
  public static ephemCusType fromPerAligned(byte[] encodedBytes) {
    ephemCusType result = new ephemCusType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemCusType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemAPowerHalfType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemAPowerHalfType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemAPowerHalfType() {
    super();
    setValueRange("0", "4294967295");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemAPowerHalfType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemAPowerHalfType != null) {
      return ImmutableList.of(TAG_ephemAPowerHalfType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemAPowerHalfType from encoded stream.
   */
  public static ephemAPowerHalfType fromPerUnaligned(byte[] encodedBytes) {
    ephemAPowerHalfType result = new ephemAPowerHalfType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemAPowerHalfType from encoded stream.
   */
  public static ephemAPowerHalfType fromPerAligned(byte[] encodedBytes) {
    ephemAPowerHalfType result = new ephemAPowerHalfType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemAPowerHalfType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemToeType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemToeType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemToeType() {
    super();
    setValueRange("0", "37799");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemToeType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemToeType != null) {
      return ImmutableList.of(TAG_ephemToeType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemToeType from encoded stream.
   */
  public static ephemToeType fromPerUnaligned(byte[] encodedBytes) {
    ephemToeType result = new ephemToeType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemToeType from encoded stream.
   */
  public static ephemToeType fromPerAligned(byte[] encodedBytes) {
    ephemToeType result = new ephemToeType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemToeType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemFitFlagType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemFitFlagType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemFitFlagType() {
    super();
    setValueRange("0", "1");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemFitFlagType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemFitFlagType != null) {
      return ImmutableList.of(TAG_ephemFitFlagType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemFitFlagType from encoded stream.
   */
  public static ephemFitFlagType fromPerUnaligned(byte[] encodedBytes) {
    ephemFitFlagType result = new ephemFitFlagType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemFitFlagType from encoded stream.
   */
  public static ephemFitFlagType fromPerAligned(byte[] encodedBytes) {
    ephemFitFlagType result = new ephemFitFlagType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemFitFlagType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemAODAType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemAODAType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemAODAType() {
    super();
    setValueRange("0", "31");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemAODAType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemAODAType != null) {
      return ImmutableList.of(TAG_ephemAODAType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemAODAType from encoded stream.
   */
  public static ephemAODAType fromPerUnaligned(byte[] encodedBytes) {
    ephemAODAType result = new ephemAODAType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemAODAType from encoded stream.
   */
  public static ephemAODAType fromPerAligned(byte[] encodedBytes) {
    ephemAODAType result = new ephemAODAType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemAODAType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemCicType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemCicType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemCicType() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemCicType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemCicType != null) {
      return ImmutableList.of(TAG_ephemCicType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemCicType from encoded stream.
   */
  public static ephemCicType fromPerUnaligned(byte[] encodedBytes) {
    ephemCicType result = new ephemCicType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemCicType from encoded stream.
   */
  public static ephemCicType fromPerAligned(byte[] encodedBytes) {
    ephemCicType result = new ephemCicType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemCicType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemOmegaA0Type extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemOmegaA0Type
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemOmegaA0Type() {
    super();
    setValueRange("-2147483648", "2147483647");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemOmegaA0Type;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemOmegaA0Type != null) {
      return ImmutableList.of(TAG_ephemOmegaA0Type);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemOmegaA0Type from encoded stream.
   */
  public static ephemOmegaA0Type fromPerUnaligned(byte[] encodedBytes) {
    ephemOmegaA0Type result = new ephemOmegaA0Type();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemOmegaA0Type from encoded stream.
   */
  public static ephemOmegaA0Type fromPerAligned(byte[] encodedBytes) {
    ephemOmegaA0Type result = new ephemOmegaA0Type();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemOmegaA0Type = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemCisType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemCisType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemCisType() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemCisType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemCisType != null) {
      return ImmutableList.of(TAG_ephemCisType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemCisType from encoded stream.
   */
  public static ephemCisType fromPerUnaligned(byte[] encodedBytes) {
    ephemCisType result = new ephemCisType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemCisType from encoded stream.
   */
  public static ephemCisType fromPerAligned(byte[] encodedBytes) {
    ephemCisType result = new ephemCisType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemCisType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemI0Type extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemI0Type
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemI0Type() {
    super();
    setValueRange("-2147483648", "2147483647");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemI0Type;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemI0Type != null) {
      return ImmutableList.of(TAG_ephemI0Type);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemI0Type from encoded stream.
   */
  public static ephemI0Type fromPerUnaligned(byte[] encodedBytes) {
    ephemI0Type result = new ephemI0Type();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemI0Type from encoded stream.
   */
  public static ephemI0Type fromPerAligned(byte[] encodedBytes) {
    ephemI0Type result = new ephemI0Type();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemI0Type = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemCrcType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemCrcType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemCrcType() {
    super();
    setValueRange("-32768", "32767");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemCrcType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemCrcType != null) {
      return ImmutableList.of(TAG_ephemCrcType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemCrcType from encoded stream.
   */
  public static ephemCrcType fromPerUnaligned(byte[] encodedBytes) {
    ephemCrcType result = new ephemCrcType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemCrcType from encoded stream.
   */
  public static ephemCrcType fromPerAligned(byte[] encodedBytes) {
    ephemCrcType result = new ephemCrcType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemCrcType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemWType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemWType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemWType() {
    super();
    setValueRange("-2147483648", "2147483647");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemWType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemWType != null) {
      return ImmutableList.of(TAG_ephemWType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemWType from encoded stream.
   */
  public static ephemWType fromPerUnaligned(byte[] encodedBytes) {
    ephemWType result = new ephemWType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemWType from encoded stream.
   */
  public static ephemWType fromPerAligned(byte[] encodedBytes) {
    ephemWType result = new ephemWType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemWType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemOmegaADotType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemOmegaADotType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemOmegaADotType() {
    super();
    setValueRange("-8388608", "8388607");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemOmegaADotType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemOmegaADotType != null) {
      return ImmutableList.of(TAG_ephemOmegaADotType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemOmegaADotType from encoded stream.
   */
  public static ephemOmegaADotType fromPerUnaligned(byte[] encodedBytes) {
    ephemOmegaADotType result = new ephemOmegaADotType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemOmegaADotType from encoded stream.
   */
  public static ephemOmegaADotType fromPerAligned(byte[] encodedBytes) {
    ephemOmegaADotType result = new ephemOmegaADotType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemOmegaADotType = " + getInteger() + ";\n";
  }
}

  
/*
 */


//

/**
 */
public static class ephemIDotType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_ephemIDotType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ephemIDotType() {
    super();
    setValueRange("-8192", "8191");

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ephemIDotType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ephemIDotType != null) {
      return ImmutableList.of(TAG_ephemIDotType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ephemIDotType from encoded stream.
   */
  public static ephemIDotType fromPerUnaligned(byte[] encodedBytes) {
    ephemIDotType result = new ephemIDotType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ephemIDotType from encoded stream.
   */
  public static ephemIDotType fromPerAligned(byte[] encodedBytes) {
    ephemIDotType result = new ephemIDotType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "ephemIDotType = " + getInteger() + ";\n";
  }
}

  

    

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    StringBuilder builder = new StringBuilder();
    builder.append("UncompressedEphemeris = {\n");
    final String internalIndent = indent + "  ";
    for (SequenceComponent component : getComponents()) {
      if (component.isExplicitlySet()) {
        builder.append(internalIndent)
            .append(component.toIndentedString(internalIndent));
      }
    }
    if (isExtensible()) {
      builder.append(internalIndent).append("...\n");
      for (SequenceComponent component : getExtensionComponents()) {
        if (component.isExplicitlySet()) {
          builder.append(internalIndent)
              .append(component.toIndentedString(internalIndent));
        }
      }
    }
    builder.append(indent).append("};\n");
    return builder.toString();
  }
}