IntervalVar.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (https://www.swig.org).
// Version 4.2.1
//
// Do not make changes to this file unless you know what you are doing - modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Google.OrTools.ConstraintSolver {
 
using System;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
 
public partial class IntervalVar : PropagationBaseObject {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 
  internal IntervalVar(global::System.IntPtr cPtr, bool cMemoryOwn) : base(operations_research_constraint_solverPINVOKE.IntervalVar_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(IntervalVar obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }
 
  internal static global::System.Runtime.InteropServices.HandleRef swigRelease(IntervalVar obj) {
    if (obj != null) {
      if (!obj.swigCMemOwn)
        throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
      global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
      obj.swigCMemOwn = false;
      obj.Dispose();
      return ptr;
    } else {
      return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
    }
  }
 
  protected override void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          operations_research_constraint_solverPINVOKE.delete_IntervalVar(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  // Keep reference to delegate to avoid GC to collect them early
  private List<VoidToVoid> closureCallbacks;
  private VoidToVoid StoreVoidToVoid(VoidToVoid closure) {
    if (closureCallbacks == null)
      closureCallbacks = new List<VoidToVoid>();
    closureCallbacks.Add(closure);
    return closure;
  }
 
  public static long kMinValidValue {
    get {
      long ret = operations_research_constraint_solverPINVOKE.IntervalVar_kMinValidValue_get();
      return ret;
    } 
  }
 
  public static long kMaxValidValue {
    get {
      long ret = operations_research_constraint_solverPINVOKE.IntervalVar_kMaxValidValue_get();
      return ret;
    } 
  }
 
  public virtual long StartMin() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_StartMin(swigCPtr);
    return ret;
  }
 
  public virtual long StartMax() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_StartMax(swigCPtr);
    return ret;
  }
 
  public virtual void SetStartMin(long m) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetStartMin(swigCPtr, m);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void SetStartMax(long m) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetStartMax(swigCPtr, m);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void SetStartRange(long mi, long ma) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetStartRange(swigCPtr, mi, ma);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual long OldStartMin() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_OldStartMin(swigCPtr);
    return ret;
  }
 
  public virtual long OldStartMax() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_OldStartMax(swigCPtr);
    return ret;
  }
 
  public virtual void WhenStartRange(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenStartRange__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenStartRange( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenStartRange__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public virtual void WhenStartBound(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenStartBound__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenStartBound( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenStartBound__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public virtual long DurationMin() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_DurationMin(swigCPtr);
    return ret;
  }
 
  public virtual long DurationMax() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_DurationMax(swigCPtr);
    return ret;
  }
 
  public virtual void SetDurationMin(long m) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetDurationMin(swigCPtr, m);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void SetDurationMax(long m) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetDurationMax(swigCPtr, m);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void SetDurationRange(long mi, long ma) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetDurationRange(swigCPtr, mi, ma);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual long OldDurationMin() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_OldDurationMin(swigCPtr);
    return ret;
  }
 
  public virtual long OldDurationMax() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_OldDurationMax(swigCPtr);
    return ret;
  }
 
  public virtual void WhenDurationRange(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenDurationRange__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenDurationRange( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenDurationRange__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public virtual void WhenDurationBound(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenDurationBound__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenDurationBound( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenDurationBound__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public virtual long EndMin() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_EndMin(swigCPtr);
    return ret;
  }
 
  public virtual long EndMax() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_EndMax(swigCPtr);
    return ret;
  }
 
  public virtual void SetEndMin(long m) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetEndMin(swigCPtr, m);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void SetEndMax(long m) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetEndMax(swigCPtr, m);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void SetEndRange(long mi, long ma) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetEndRange(swigCPtr, mi, ma);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual long OldEndMin() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_OldEndMin(swigCPtr);
    return ret;
  }
 
  public virtual long OldEndMax() {
    long ret = operations_research_constraint_solverPINVOKE.IntervalVar_OldEndMax(swigCPtr);
    return ret;
  }
 
  public virtual void WhenEndRange(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenEndRange__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenEndRange( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenEndRange__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public virtual void WhenEndBound(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenEndBound__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenEndBound( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenEndBound__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public virtual bool MustBePerformed() {
    bool ret = operations_research_constraint_solverPINVOKE.IntervalVar_MustBePerformed(swigCPtr);
    return ret;
  }
 
  public virtual bool MayBePerformed() {
    bool ret = operations_research_constraint_solverPINVOKE.IntervalVar_MayBePerformed(swigCPtr);
    return ret;
  }
 
  public bool CannotBePerformed() {
    bool ret = operations_research_constraint_solverPINVOKE.IntervalVar_CannotBePerformed(swigCPtr);
    return ret;
  }
 
  public bool IsPerformedBound() {
    bool ret = operations_research_constraint_solverPINVOKE.IntervalVar_IsPerformedBound(swigCPtr);
    return ret;
  }
 
  public virtual void SetPerformed(bool val) {
    operations_research_constraint_solverPINVOKE.IntervalVar_SetPerformed(swigCPtr, val);
    if (operations_research_constraint_solverPINVOKE.SWIGPendingException.Pending) throw operations_research_constraint_solverPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool WasPerformedBound() {
    bool ret = operations_research_constraint_solverPINVOKE.IntervalVar_WasPerformedBound(swigCPtr);
    return ret;
  }
 
  public virtual void WhenPerformedBound(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenPerformedBound__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenPerformedBound( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenPerformedBound__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public void WhenAnything(Demon d) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenAnything__SWIG_0(swigCPtr, Demon.getCPtr(d));
  }
 
  public void WhenAnything( VoidToVoid  closure) {
    operations_research_constraint_solverPINVOKE.IntervalVar_WhenAnything__SWIG_1(swigCPtr,  StoreVoidToVoid(closure) );
  }
 
  public virtual IntExpr StartExpr() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartExpr(swigCPtr);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual IntExpr DurationExpr() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_DurationExpr(swigCPtr);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual IntExpr EndExpr() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndExpr(swigCPtr);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual IntExpr PerformedExpr() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_PerformedExpr(swigCPtr);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual IntExpr SafeStartExpr(long unperformed_value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_SafeStartExpr(swigCPtr, unperformed_value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual IntExpr SafeDurationExpr(long unperformed_value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_SafeDurationExpr(swigCPtr, unperformed_value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual IntExpr SafeEndExpr(long unperformed_value) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_SafeEndExpr(swigCPtr, unperformed_value);
    IntExpr ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntExpr(cPtr, false);
    return ret;
  }
 
  public virtual void Accept(ModelVisitor visitor) {
    operations_research_constraint_solverPINVOKE.IntervalVar_Accept(swigCPtr, ModelVisitor.getCPtr(visitor));
  }
 
  public Constraint EndsAfterEnd(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAfterEnd(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAfterStart(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAfterStart(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAtEnd(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAtEnd(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAtStart(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAtStart(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAfterEnd(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAfterEnd(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAfterStart(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAfterStart(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAtEnd(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAtEnd(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAtStart(IntervalVar other) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAtStart(swigCPtr, IntervalVar.getCPtr(other));
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAfterEndWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAfterEndWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAfterStartWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAfterStartWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAtEndWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAtEndWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAtStartWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAtStartWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAfterEndWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAfterEndWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAfterStartWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAfterStartWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAtEndWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAtEndWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAtStartWithDelay(IntervalVar other, long delay) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAtStartWithDelay(swigCPtr, IntervalVar.getCPtr(other), delay);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAfter(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAfter(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsAt(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsAt(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint EndsBefore(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_EndsBefore(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAfter(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAfter(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsAt(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsAt(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint StartsBefore(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_StartsBefore(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint CrossesDate(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_CrossesDate(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public Constraint AvoidsDate(long date) {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_AvoidsDate(swigCPtr, date);
    Constraint ret = (cPtr == global::System.IntPtr.Zero) ? null : new Constraint(cPtr, false);
    return ret;
  }
 
  public IntervalVar RelaxedMax() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_RelaxedMax(swigCPtr);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
  public IntervalVar RelaxedMin() {
    global::System.IntPtr cPtr = operations_research_constraint_solverPINVOKE.IntervalVar_RelaxedMin(swigCPtr);
    IntervalVar ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntervalVar(cPtr, false);
    return ret;
  }
 
}
 
}