diff --git a/cpp/src/Slice/CsUtil.cpp b/cpp/src/Slice/CsUtil.cpp
index 624ed70..a78e55a 100644
--- a/cpp/src/Slice/CsUtil.cpp
+++ b/cpp/src/Slice/CsUtil.cpp
@@ -401,7 +401,7 @@ Slice::CsGenerator::isValueType(const TypePtr& type)
         DataMemberList dm = s->dataMembers();
         for(DataMemberList::const_iterator i = dm.begin(); i != dm.end(); ++i)
         {
-            if(!isValueType((*i)->type()))
+            if(!isValueType((*i)->type()) || (*i)->defaultValueType())
             {
                 return false;
             }
diff --git a/cpp/src/slice2cs/Gen.cpp b/cpp/src/slice2cs/Gen.cpp
index 8d6cb6e..6016457 100644
--- a/cpp/src/slice2cs/Gen.cpp
+++ b/cpp/src/slice2cs/Gen.cpp
@@ -858,7 +858,7 @@ Slice::CsVisitor::writeDispatchAndMarshalling(const ClassDefPtr& p, bool stream)
                     StructPtr st = StructPtr::dynamicCast((*pli)->type());
                     if(st)
                     {
-                        if(isValueType((*pli)->type()))
+                        if(isValueType(st))
                         {
                             _out << nl << param << " = new " << typeS << "();";
                         }
@@ -3700,7 +3700,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p)
 
     emitAttributes(p);
     emitPartialTypeAttributes();
-    if(isValueType(p) && !p->hasDefaultValues())
+    if(isValueType(p))
     {
         _out << nl << "public partial struct " << name;
     }
@@ -3727,7 +3727,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
     _out << sp << nl << "#endregion"; // Slice data members
 
-    const bool isClass = !isValueType(p) || p->hasDefaultValues();
+    const bool isClass = !isValueType(p);
 
     _out << sp << nl << "#region Constructor";
     if(isClass)
@@ -4126,7 +4126,7 @@ Slice::Gen::TypesVisitor::visitDataMember(const DataMemberPtr& p)
     if(StructPtr::dynamicCast(cont))
     {
         isValue = isValueType(StructPtr::dynamicCast(cont));
-        if(!isValue || cont->hasMetaData("clr:class"))
+        if(!isValue)
         {
             baseTypes = DotNet::ICloneable;
         }
@@ -4998,7 +4998,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
                         StructPtr st = StructPtr::dynamicCast((*pli)->type());
                         if(st)
                         {
-                            if(isValueType((*pli)->type()))
+                            if(isValueType(st))
                             {
                                 _out << nl << param << " = new " << typeS << "();";
                             }
@@ -5019,7 +5019,7 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
                         StructPtr st = StructPtr::dynamicCast(ret);
                         if(st)
                         {
-                            if(isValueType(ret))
+                            if(isValueType(st))
                             {
                                 _out << nl << "ret__ = new " << typeS << "();";
                             }
@@ -5684,7 +5684,7 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
     StructPtr st = StructPtr::dynamicCast(key);
     if(st)
     {
-        if(isValueType(key))
+        if(isValueType(st))
         {
             _out << nl << "k__ = new " << typeToString(key) << "();";
         }
@@ -5707,7 +5707,7 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
         StructPtr st = StructPtr::dynamicCast(value);
         if(st)
         {
-            if(isValueType(value))
+            if(isValueType(st))
             {
                 _out << nl << "v__ = new " << typeToString(value) << "();";
             }
@@ -5764,7 +5764,7 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
         StructPtr st = StructPtr::dynamicCast(key);
         if(st)
         {
-            if(isValueType(key))
+            if(isValueType(st))
             {
                 _out << nl << "k__ = new " << typeToString(key) << "();";
             }
@@ -5780,7 +5780,7 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
             StructPtr st = StructPtr::dynamicCast(value);
             if(st)
             {
-                if(isValueType(value))
+                if(isValueType(st))
                 {
                     _out << nl << "v__ = new " << typeToString(value) << "();";
                 }
@@ -6075,7 +6075,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
                     StructPtr st = StructPtr::dynamicCast(ret);
                     if(st)
                     {
-                        if(isValueType(ret))
+                        if(isValueType(st))
                         {
                             _out << nl << "ret__ = new " << typeS << "();";
                         }
diff --git a/cs/test/Ice/seqMapping/MyClassAMDI.cs b/cs/test/Ice/seqMapping/MyClassAMDI.cs
index 3a8abe1..17989ff 100644
--- a/cs/test/Ice/seqMapping/MyClassAMDI.cs
+++ b/cs/test/Ice/seqMapping/MyClassAMDI.cs
@@ -334,6 +334,36 @@ public sealed class MyClassI : MyClass
         cb.ice_response(i, i);
     }
 
+    public override void opAStructSD_async(AMD_MyClass_opAStructSD cb, SD[] i, Ice.Current current)
+    {
+        cb.ice_response(i, i);
+    }
+
+    public override void opLStructSD_async(AMD_MyClass_opLStructSD cb, List<SD> i, Ice.Current current)
+    {
+        cb.ice_response(i, i);
+    }
+
+    public override void opKStructSD_async(AMD_MyClass_opKStructSD cb, LinkedList<SD> i, Ice.Current current)
+    {
+        cb.ice_response(i, i);
+    }
+
+    public override void opQStructSD_async(AMD_MyClass_opQStructSD cb, Queue<SD> i, Ice.Current current)
+    {
+        cb.ice_response(i, i);
+    }
+
+    public override void opSStructSD_async(AMD_MyClass_opSStructSD cb, Stack<SD> i, Ice.Current current)
+    {
+        cb.ice_response(i, i);
+    }
+
+    public override void opCStructSD_async(AMD_MyClass_opCStructSD cb, CStructSD i, Ice.Current current)
+    {
+        cb.ice_response(i, i);
+    }
+
     public override void opACVS_async(AMD_MyClass_opACVS cb, CV[] i, Ice.Current current)
     {
         cb.ice_response(i, i);
diff --git a/cs/test/Ice/seqMapping/MyClassI.cs b/cs/test/Ice/seqMapping/MyClassI.cs
index f54dfac..7ac7987 100644
--- a/cs/test/Ice/seqMapping/MyClassI.cs
+++ b/cs/test/Ice/seqMapping/MyClassI.cs
@@ -396,6 +396,42 @@ public sealed class MyClassI : Test.MyClass
         return i;
     }
 
+    public override SD[] opAStructSD(SD[] i, out SD[] o, Ice.Current current)
+    {
+        o = i;
+        return i;
+    }
+
+    public override List<SD> opLStructSD(List<SD> i, out List<SD> o, Ice.Current current)
+    {
+        o = i;
+        return i;
+    }
+
+    public override LinkedList<SD> opKStructSD(LinkedList<SD> i, out LinkedList<SD> o, Ice.Current current)
+    {
+        o = i;
+        return i;
+    }
+
+    public override Queue<SD> opQStructSD(Queue<SD> i, out Queue<SD> o, Ice.Current current)
+    {
+        o = i;
+        return i;
+    }
+
+    public override Stack<SD> opSStructSD(Stack<SD> i, out Stack<SD> o, Ice.Current current)
+    {
+        o = i;
+        return i;
+    }
+
+    public override CStructSD opCStructSD(CStructSD i, out CStructSD o, Ice.Current current)
+    {
+        o = i;
+        return i;
+    }
+
     public override CV[] opACVS(CV[] i, out CV[] o, Ice.Current current)
     {
         o = i;
diff --git a/cs/test/Ice/seqMapping/Test.ice b/cs/test/Ice/seqMapping/Test.ice
index 27f9e2e..ba61076 100644
--- a/cs/test/Ice/seqMapping/Test.ice
+++ b/cs/test/Ice/seqMapping/Test.ice
@@ -91,6 +91,18 @@ sequence<S> AStructS;
 ["clr:generic:Stack"] sequence<S> SStructS;
 ["clr:collection"] sequence<S> CStructS;
 
+struct SD
+{
+    int i = 1;
+};
+
+sequence<SD> AStructSD;
+["clr:generic:List"] sequence<SD> LStructSD;
+["clr:generic:LinkedList"] sequence<SD> KStructSD;
+["clr:generic:Queue"] sequence<SD> QStructSD;
+["clr:generic:Stack"] sequence<SD> SStructSD;
+["clr:collection"] sequence<SD> CStructSD;
+
 class CV
 {
     int i;
@@ -215,6 +227,13 @@ sequence<En> AEnS;
     SStructS opSStructS(SStructS i, out SStructS o);
     CStructS opCStructS(CStructS i, out CStructS o);
 
+    AStructSD opAStructSD(AStructSD i, out AStructSD o);
+    LStructSD opLStructSD(LStructSD i, out LStructSD o);
+    KStructSD opKStructSD(KStructSD i, out KStructSD o);
+    QStructSD opQStructSD(QStructSD i, out QStructSD o);
+    SStructSD opSStructSD(SStructSD i, out SStructSD o);
+    CStructSD opCStructSD(CStructSD i, out CStructSD o);
+
     ACVS opACVS(ACVS i, out ACVS o);
     LCVS opLCVS(LCVS i, out LCVS o);
     CCVS opCCVS(CCVS i, out CCVS o);
diff --git a/cs/test/Ice/seqMapping/TestAMD.ice b/cs/test/Ice/seqMapping/TestAMD.ice
index 3cf6af0..38495e1 100644
--- a/cs/test/Ice/seqMapping/TestAMD.ice
+++ b/cs/test/Ice/seqMapping/TestAMD.ice
@@ -91,6 +91,18 @@ sequence<S> AStructS;
 ["clr:generic:Stack"] sequence<S> SStructS;
 ["clr:collection"] sequence<S> CStructS;
 
+struct SD
+{
+    int i = 1;
+};
+
+sequence<SD> AStructSD;
+["clr:generic:List"] sequence<SD> LStructSD;
+["clr:generic:LinkedList"] sequence<SD> KStructSD;
+["clr:generic:Queue"] sequence<SD> QStructSD;
+["clr:generic:Stack"] sequence<SD> SStructSD;
+["clr:collection"] sequence<SD> CStructSD;
+
 class CV
 {
     int i;
@@ -213,6 +225,13 @@ sequence<En> AEnS;
     SStructS opSStructS(SStructS i, out SStructS o);
     CStructS opCStructS(CStructS i, out CStructS o);
 
+    AStructSD opAStructSD(AStructSD i, out AStructSD o);
+    LStructSD opLStructSD(LStructSD i, out LStructSD o);
+    KStructSD opKStructSD(KStructSD i, out KStructSD o);
+    QStructSD opQStructSD(QStructSD i, out QStructSD o);
+    SStructSD opSStructSD(SStructSD i, out SStructSD o);
+    CStructSD opCStructSD(CStructSD i, out CStructSD o);
+
     ACVS opACVS(ACVS i, out ACVS o);
     LCVS opLCVS(LCVS i, out LCVS o);
     CCVS opCCVS(CCVS i, out CCVS o);
diff --git a/cs/test/Ice/seqMapping/Twoways.cs b/cs/test/Ice/seqMapping/Twoways.cs
index afb5e7f..49ab182 100644
--- a/cs/test/Ice/seqMapping/Twoways.cs
+++ b/cs/test/Ice/seqMapping/Twoways.cs
@@ -994,6 +994,97 @@ class Twoways
         }
 
         {
+            SD[] i = new SD[_length];
+            for(int c = 0; c < _length; ++c)
+            {
+                i[c] = new SD(c);
+            }
+            SD[] o;
+            SD[] r;
+
+            r = p.opAStructSD(i, out o);
+
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+        }
+
+        {
+            List<SD> i = new List<SD>(_length);
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Add(new SD(c));
+            }
+            List<SD> o;
+            List<SD> r;
+
+            r = p.opLStructSD(i, out o);
+
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+        }
+
+        {
+            LinkedList<SD> i = new LinkedList<SD>();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.AddLast(new SD(c));
+            }
+            LinkedList<SD> o;
+            LinkedList<SD> r;
+
+            r = p.opKStructSD(i, out o);
+
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+        }
+
+        {
+            Queue<SD> i = new Queue<SD>();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Enqueue(new SD(c));
+            }
+            Queue<SD> o;
+            Queue<SD> r;
+
+            r = p.opQStructSD(i, out o);
+
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+        }
+
+        {
+            Stack<SD> i = new Stack<SD>();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Push(new SD(c));
+            }
+            Stack<SD> o;
+            Stack<SD> r;
+
+
+            r = p.opSStructSD(i, out o);
+
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+        }
+
+        {
+            CStructSD i = new CStructSD(_length);
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Add(new SD(c));
+            }
+            CStructSD o;
+            CStructSD r;
+
+            r = p.opCStructSD(i, out o);
+
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+        }
+
+        {
             CV[] i = new CV[_length];
             for(int c = 0; c < _length; ++c)
             {
diff --git a/cs/test/Ice/seqMapping/TwowaysAMI.cs b/cs/test/Ice/seqMapping/TwowaysAMI.cs
index 9ca951a..bca1277 100644
--- a/cs/test/Ice/seqMapping/TwowaysAMI.cs
+++ b/cs/test/Ice/seqMapping/TwowaysAMI.cs
@@ -1852,6 +1852,174 @@ public class TwowaysAMI
         private Callback callback = new Callback();
     }
 
+    private class AMI_MyClass_opAStructSDI : Test.AMI_MyClass_opAStructSD
+    {
+        public AMI_MyClass_opAStructSDI(SD[] i)
+        {
+            _i = i;
+        }
+
+        public override void ice_response(SD[] r, SD[] o)
+        {
+            test(Ice.CollectionComparer.Equals(_i, o));
+            test(Ice.CollectionComparer.Equals(_i, r));
+            callback.called();
+        }
+
+        public override void ice_exception(Ice.Exception ex)
+        {
+            test(false);
+        }
+
+        public virtual void check()
+        {
+             callback.check();
+        }
+
+        private SD[] _i;
+        private Callback callback = new Callback();
+    }
+
+    private class AMI_MyClass_opLStructSDI : Test.AMI_MyClass_opLStructSD
+    {
+        public AMI_MyClass_opLStructSDI(List<SD> i)
+        {
+            _i = i;
+        }
+
+        public override void ice_response(List<SD> r, List<SD> o)
+        {
+            test(Ice.CollectionComparer.Equals(_i, o));
+            test(Ice.CollectionComparer.Equals(_i, r));
+            callback.called();
+        }
+
+        public override void ice_exception(Ice.Exception ex)
+        {
+            test(false);
+        }
+
+        public virtual void check()
+        {
+             callback.check();
+        }
+
+        private List<SD> _i;
+        private Callback callback = new Callback();
+    }
+
+    private class AMI_MyClass_opKStructSDI : Test.AMI_MyClass_opKStructSD
+    {
+        public AMI_MyClass_opKStructSDI(LinkedList<SD> i)
+        {
+            _i = i;
+        }
+
+        public override void ice_response(LinkedList<SD> r, LinkedList<SD> o)
+        {
+            test(Ice.CollectionComparer.Equals(_i, o));
+            test(Ice.CollectionComparer.Equals(_i, r));
+            callback.called();
+        }
+
+        public override void ice_exception(Ice.Exception ex)
+        {
+            test(false);
+        }
+
+        public virtual void check()
+        {
+             callback.check();
+        }
+
+        private LinkedList<SD> _i;
+        private Callback callback = new Callback();
+    }
+
+    private class AMI_MyClass_opQStructSDI : Test.AMI_MyClass_opQStructSD
+    {
+        public AMI_MyClass_opQStructSDI(Queue<SD> i)
+        {
+            _i = i;
+        }
+
+        public override void ice_response(Queue<SD> r, Queue<SD> o)
+        {
+            test(Ice.CollectionComparer.Equals(_i, o));
+            test(Ice.CollectionComparer.Equals(_i, r));
+            callback.called();
+        }
+
+        public override void ice_exception(Ice.Exception ex)
+        {
+            test(false);
+        }
+
+        public virtual void check()
+        {
+             callback.check();
+        }
+
+        private Queue<SD> _i;
+        private Callback callback = new Callback();
+    }
+
+    private class AMI_MyClass_opSStructSDI : Test.AMI_MyClass_opSStructSD
+    {
+        public AMI_MyClass_opSStructSDI(Stack<SD> i)
+        {
+            _i = i;
+        }
+
+        public override void ice_response(Stack<SD> r, Stack<SD> o)
+        {
+            test(Ice.CollectionComparer.Equals(_i, o));
+            test(Ice.CollectionComparer.Equals(_i, r));
+            callback.called();
+        }
+
+        public override void ice_exception(Ice.Exception ex)
+        {
+            test(false);
+        }
+
+        public virtual void check()
+        {
+             callback.check();
+        }
+
+        private Stack<SD> _i;
+        private Callback callback = new Callback();
+    }
+
+    private class AMI_MyClass_opCStructSDI : Test.AMI_MyClass_opCStructSD
+    {
+        public AMI_MyClass_opCStructSDI(CStructSD i)
+        {
+            _i = i;
+        }
+
+        public override void ice_response(CStructSD r, CStructSD o)
+        {
+            test(Ice.CollectionComparer.Equals(_i, o));
+            test(Ice.CollectionComparer.Equals(_i, r));
+            callback.called();
+        }
+
+        public override void ice_exception(Ice.Exception ex)
+        {
+            test(false);
+        }
+
+        public virtual void check()
+        {
+             callback.check();
+        }
+
+        private CStructSD _i;
+        private Callback callback = new Callback();
+    }
+
     private class AMI_MyClass_opACVSI : Test.AMI_MyClass_opACVS
     {
         public AMI_MyClass_opACVSI(CV[] i)
@@ -3442,6 +3610,78 @@ public class TwowaysAMI
         }
 
         {
+            SD[] i = new SD[_length];
+            for(int c = 0; c < _length; ++c)
+            {
+                i[c] = new SD(c);
+            }
+
+            AMI_MyClass_opAStructSDI cb = new AMI_MyClass_opAStructSDI(i);
+            p.opAStructSD_async(cb, i);
+            cb.check();
+        }
+
+        {
+            List<SD> i = new List<SD>();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Add(new SD(c));
+            }
+
+            AMI_MyClass_opLStructSDI cb = new AMI_MyClass_opLStructSDI(i);
+            p.opLStructSD_async(cb, i);
+            cb.check();
+        }
+
+        {
+            LinkedList<SD> i = new LinkedList<SD>();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.AddLast(new SD(c));
+            }
+
+            AMI_MyClass_opKStructSDI cb = new AMI_MyClass_opKStructSDI(i);
+            p.opKStructSD_async(cb, i);
+            cb.check();
+        }
+
+        {
+            Queue<SD> i = new Queue<SD>();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Enqueue(new SD(c));
+            }
+
+            AMI_MyClass_opQStructSDI cb = new AMI_MyClass_opQStructSDI(i);
+            p.opQStructSD_async(cb, i);
+            cb.check();
+        }
+
+        {
+            Stack<SD> i = new Stack<SD>();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Push(new SD(c));
+            }
+
+            AMI_MyClass_opSStructSDI cb = new AMI_MyClass_opSStructSDI(i);
+            p.opSStructSD_async(cb, i);
+            cb.check();
+        }
+
+        {
+            CStructSD i = new CStructSD();
+            for(int c = 0; c < _length; ++c)
+            {
+                i.Add(new SD(c));
+            }
+
+            AMI_MyClass_opCStructSDI cb = new AMI_MyClass_opCStructSDI(i);
+            p.opCStructSD_async(cb, i);
+            cb.check();
+        }
+
+        {
             CV[] i = new CV[_length];
             for(int c = 0; c < _length; ++c)
             {
diff --git a/cs/test/Ice/seqMapping/TwowaysNewAMI.cs b/cs/test/Ice/seqMapping/TwowaysNewAMI.cs
index 32262d4..b41621d 100644
--- a/cs/test/Ice/seqMapping/TwowaysNewAMI.cs
+++ b/cs/test/Ice/seqMapping/TwowaysNewAMI.cs
@@ -720,7 +720,67 @@ public class TwowaysNewAMI
             test(Ice.CollectionComparer.Equals(i, r));
             callback.called();
         }
-        
+
+        public void opAStructSDI(Ice.AsyncResult result)
+        {
+            SD[] i = (SD[])result.AsyncState;
+            SD[] o;
+            SD[] r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAStructSD(out o, result);
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+            callback.called();
+        }
+
+        public void opLStructSDI(Ice.AsyncResult result)
+        {
+            List<SD> i = (List<SD>)result.AsyncState;
+            List<SD> o;
+            List<SD> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLStructSD(out o, result);
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+            callback.called();
+        }
+
+        public void opKStructSDI(Ice.AsyncResult result)
+        {
+            LinkedList<SD> i = (LinkedList<SD>)result.AsyncState;
+            LinkedList<SD> o;
+            LinkedList<SD> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKStructSD(out o, result);
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+            callback.called();
+        }
+
+        public void opQStructSDI(Ice.AsyncResult result)
+        {
+            Queue<SD> i = (Queue<SD>)result.AsyncState;
+            Queue<SD> o;
+            Queue<SD> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQStructSD(out o, result);
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+            callback.called();
+        }
+
+        public void opSStructSDI(Ice.AsyncResult result)
+        {
+            Stack<SD> i = (Stack<SD>)result.AsyncState;
+            Stack<SD> o;
+            Stack<SD> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSStructSD(out o, result);
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+            callback.called();
+        }
+
+        public void opCStructSDI(Ice.AsyncResult result)
+        {
+            CStructSD i = (CStructSD)result.AsyncState;
+            CStructSD o;
+            CStructSD r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opCStructSD(out o, result);
+            test(Ice.CollectionComparer.Equals(i, o));
+            test(Ice.CollectionComparer.Equals(i, r));
+            callback.called();
+        }
+
         public void opACVSI(Ice.AsyncResult result)
         {
             CV[] i = (CV[])result.AsyncState;