private float getLoadedTransmitterCost(IScienceDataTransmitter transmitter)
{
double d = 1000000;
PartModule pMod = transmitter as PartModule;
if (pMod != null)
{
switch (pMod.moduleName)
{
case "ModuleDataTransmitter":
ModuleDataTransmitter tran = pMod as ModuleDataTransmitter;
if (tran != null)
{
d = tran.packetResourceCost / tran.packetSize;
}
break;
case "ModuleRTDataTransmitter":
float cost = pMod.Fields["PacketResourceCost"].GetValue <float>(pMod);
float size = pMod.Fields["PacketSize"].GetValue <float>(pMod);
d = cost / size;
break;
default:
break;
}
}
return((float)d);
}
private void onTransmitData(ScienceData data)
{
results = null;
if (handler == null)
{
return;
}
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(vessel);
if (bestTransmitter != null)
{
SEP_Utilities.log("Sending data to vessel comms: {0}", logLevels.log, data.title);
bestTransmitter.TransmitData(new List <ScienceData> {
data
});
DumpData(data);
}
else if (CommNet.CommNetScenario.CommNetEnabled)
{
ScreenMessages.PostScreenMessage("No usable, in-range Comms Devices on this vessel. Cannot Transmit Data.", 3f, ScreenMessageStyle.UPPER_CENTER);
}
else
{
ScreenMessages.PostScreenMessage("No Comms Devices on this vessel. Cannot Transmit Data.", 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
public Result <object, string> TransmitData()
{
ScienceData[] data = experiment.GetData();
ScienceData scienceData;
for (int i = 0; i < data.Length; ++i)
{
scienceData = data[i];
ExperimentResultDialogPage page = new ExperimentResultDialogPage(
partModule.part, scienceData, scienceData.baseTransmitValue, scienceData.transmitBonus,
false, "", false,
new ScienceLabSearch(vesselAdapter.vessel, scienceData),
null, null, null, null);
}
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(vesselAdapter.vessel);
if (bestTransmitter != null)
{
bestTransmitter.TransmitData(data.ToList());
Array.ForEach(experiment.GetData(), experiment.DumpData);
if (experiment.useCooldown)
{
experiment.cooldownToGo = experiment.cooldownTimer;
}
return(Result.Ok <object, string>(null));
}
return(Result.Err <object, string>("No transmitters available on this vessel or no data to transmit."));
}
private void onTransmitData(ScienceData data)
{
results = null;
if (handler == null)
{
return;
}
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(vessel);
if (bestTransmitter != null)
{
SEP_Utilities.log("Sending data to vessel comms: {0}", logLevels.log, data.title);
bestTransmitter.TransmitData(new List <ScienceData> {
data
});
DumpData(data);
}
else if (CommNet.CommNetScenario.CommNetEnabled)
{
ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_237738"), 3f, ScreenMessageStyle.UPPER_CENTER);
}
else
{
ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_237740"), 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
private void TransmissionComplete(IScienceDataTransmitter transmitter, Callback original)
{
Log.Debug("ALERT:Received TransmissionComplete callback from " + transmitter.GetType().Name);
if (original != null)
{
original();
}
}
private void QueueTransmission(List <ScienceData> data, IScienceDataTransmitter transmitter, Callback callback)
{
if (data.Count == 0)
{
return;
}
Log.Debug("ALERT:Queued " + data.Count + " science reports for transmission");
toBeTransmitted[transmitter].Enqueue(new KeyValuePair <List <ScienceData>, Callback>(new List <ScienceData>(data), callback));
}
private void RemoveTransmitter()
{
RTLog.Notify("ModuleRTAntenna: Remove TRANSMITTER success.");
if (mTransmitter == null)
{
return;
}
part.RemoveModule((PartModule)mTransmitter);
mTransmitter = null;
}
private void RemoveTransmitter()
{
RTLog.Notify("ModuleRTAntenna: Remove TRANSMITTER success.");
if (mTransmitter == null)
{
return;
}
part.RemoveModule((PartModule)mTransmitter);
mTransmitter = null;
// Trigger onVesselWasModified after removing the transmitter
GameEvents.onVesselWasModified.Fire(this.part.vessel);
}
/// <summary>
/// A suitable transmitter has been selected to submit some data. We'll queue
/// it for transmission in the next Update().
/// </summary>
/// <param name="data"></param>
/// <param name="transmitter"></param>
private void QueueTransmission(ScienceDataList data, IScienceDataTransmitter transmitter)
{
if (data.Count == 0)
{
return;
}
#if DEBUG
if (!realTransmitters.ContainsKey(transmitter))
{
Log.Error("MagicDataTransmitter.DoTransmit - Given transmitter isn't in real transmitter list!");
}
#endif
toBeTransmitted[transmitter].AddRange(data);
}
private void _onPageTransmit(ScienceData data)
{
IScienceDataTransmitter transmitter = ScienceUtil.GetBestTransmitter(vessel);
if (transmitter != null)
{
List <ScienceData> dataToSend = new List <ScienceData>();
dataToSend.Add(data);
transmitter.TransmitData(dataToSend);
scienceData.Remove(data);
}
else
{
ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_TST_0079"), 3f, ScreenMessageStyle.UPPER_CENTER); //#autoLOC_TST_0079 = No Comms Devices on this vessel. Cannot Transmit Data.
}
}
private void _onPageTransmit(ScienceData data)
{
IScienceDataTransmitter transmitter = ScienceUtil.GetBestTransmitter(vessel);
if (transmitter != null)
{
List <ScienceData> dataToSend = new List <ScienceData>();
dataToSend.Add(data);
transmitter.TransmitData(dataToSend);
_scienceData.Remove(data);
updateAvailableEvents();
}
else
{
ScreenMessages.PostScreenMessage(cacheautoLOC_TST_0079, 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
public void RefreshTransmitterQueues(List <KeyValuePair <List <ScienceData>, Callback> > queuedData)
{
if (queuedData == null)
{
throw new System.ArgumentNullException("queuedData");
}
Dictionary <IScienceDataTransmitter, KeyValuePair <List <ScienceData>, Callback> > dictionary = new Dictionary <IScienceDataTransmitter, KeyValuePair <List <ScienceData>, Callback> >(realTransmitters);
realTransmitters.Clear();
toBeTransmitted.Clear();
List <IScienceDataTransmitter> list = (from tx in FlightGlobals.ActiveVessel.FindPartModulesImplementing <IScienceDataTransmitter>()
where !(tx is MagicDataTransmitter)
select tx).ToList();
if (!list.Any())
{
Destroy(this);
cacheOwner.ScheduleRebuild();
}
for (int i = list.Count - 1; i >= 0; i--)
{
IScienceDataTransmitter current = list[i];
realTransmitters.Add(current, default(KeyValuePair <List <ScienceData>, Callback>));
toBeTransmitted.Add(current, new Queue <KeyValuePair <List <ScienceData>, Callback> >());
}
Log.Debug("ALERT:MagicDataTransmitter has found {0} useable transmitters", list.Count);
foreach (IScienceDataTransmitter current2 in dictionary.Keys)
{
if (realTransmitters.ContainsKey(current2))
{
realTransmitters[current2] = dictionary[current2];
}
}
if (!queuedData.Any())
{
return;
}
foreach (KeyValuePair <List <ScienceData>, Callback> current3 in queuedData)
{
TransmitData(current3.Key, current3.Value);
}
}
public override void TransmitData()
{
ThrowIfNotCPUVessel();
// This logic is mostly copied to DMScienceExperimentFields, make sure that changes here are copied there
ScienceData[] data = container.GetData();
ScienceData scienceData;
for (int i = 0; i < data.Length; ++i)
{
scienceData = data[i];
// By using ExperimentResultDialogPage we ensure that the logic calculating the value is exactly the same
// as that used KSP's dialog. The page type doesn't include any UI code itself, it just does the math to
// confirm the values, and stores some callbacks for the UI to call when buttons are pressed.
ExperimentResultDialogPage page = new ExperimentResultDialogPage(
module.part, scienceData, scienceData.baseTransmitValue, scienceData.transmitBonus, // the parameters with data we care aboue
false, "", false, // disable transmit warning and reset option, these are used for the UI only
new ScienceLabSearch(module.part.vessel, scienceData), // this is used to calculate the transmit bonus, I think...
null, null, null, null); // null callbacks, no sense in creating objects when we won't actually perform the callback.
// The dialog page modifies the referenced object, so our reference has been updated.
}
// Logic pulled from ModuleScienceExperiment.sendDataToComms
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(module.vessel);
if (bestTransmitter != null)
{
bestTransmitter.TransmitData(data.ToList());
for (int i = 0; i < data.Length; ++i)
{
container.DumpData(data[i]); // DumpData calls endExperiment, and handles setting as inoperable
}
if (module.useCooldown)
{
module.cooldownToGo = module.cooldownTimer;
}
}
else
{
ScreenMessages.PostScreenMessage("No transmitters available on this vessel or no data to transmit.", 4f, ScreenMessageStyle.UPPER_LEFT);
}
}
private void _onPageTransmit(ScienceData data)
{
List <IScienceDataTransmitter> transmitters = vessel.FindPartModulesImplementing <IScienceDataTransmitter>();
if (transmitters.Count > 0)
{
IScienceDataTransmitter transmitter = transmitters.FirstOrDefault(t => t.CanTransmit());
if (transmitter != null)
{
transmitter.TransmitData(new List <ScienceData> {
data
});
_DataAmount -= data.dataAmount;
scienceData.Remove(data);
}
}
else
{
ScreenMessages.PostScreenMessage("No Comms Devices on this vessel. Cannot Transmit Data.", 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
private void onTransmitData(ScienceData data)
{
resultsDialog = null;
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(vessel);
if (bestTransmitter != null)
{
bestTransmitter.TransmitData(new List <ScienceData> {
data
});
DumpData(data);
}
else if (CommNet.CommNetScenario.CommNetEnabled)
{
ScreenMessages.PostScreenMessage("No usable, in-range Comms Devices on this vessel. Cannot Transmit Data.", 3f, ScreenMessageStyle.UPPER_CENTER);
}
else
{
ScreenMessages.PostScreenMessage("No Comms Devices on this vessel. Cannot Transmit Data.", 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
private void onTransmitData(ScienceData data)
{
resultsDialog = null;
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(vessel);
if (bestTransmitter != null)
{
bestTransmitter.TransmitData(new List <ScienceData> {
data
});
DumpData(data);
}
else if (CommNet.CommNetScenario.CommNetEnabled)
{
ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_237738"), 3f, ScreenMessageStyle.UPPER_CENTER);
}
else
{
ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_237740"), 3f, ScreenMessageStyle.UPPER_CENTER);
}
}
private void BeginTransmissionWithRealTransmitter(IScienceDataTransmitter transmitter, List <ScienceData> science, Callback callback)
{
if (transmitter == null)
{
throw new System.ArgumentNullException("transmitter");
}
if (science == null)
{
throw new System.ArgumentNullException("science");
}
if ((PartModule)transmitter == null)
{
TransmitData(science, callback);
throw new NonexistentTransmitterException();
}
Log.Debug(string.Concat("Beginning real transmission of ", science.Count, " science reports on transmitter ", ((PartModule)transmitter).part.flightID));
if (callback != null)
{
return;
}
transmitter.TransmitData(science);
}
private void AddTransmitter()
{
if (mTransmitterConfig == null || !mTransmitterConfig.HasValue("name"))
{
return;
}
var transmitters = part.FindModulesImplementing <IScienceDataTransmitter>();
if (transmitters.Count > 0)
{
RTLog.Notify("ModuleRTAntenna: Find TRANSMITTER success.");
mTransmitter = transmitters.First();
}
else
{
var copy = new ConfigNode();
mTransmitterConfig.CopyTo(copy);
part.AddModule(copy);
AddTransmitter();
RTLog.Notify("ModuleRTAntenna: Add TRANSMITTER success.");
}
}
private void OnTransmitData(ScienceData data)
{
_expDialog = null;
IScienceDataTransmitter transmitter = ScienceUtil.GetBestTransmitter(FlightGlobals.ActiveVessel);
if (transmitter != null)
{
transmitter.TransmitData(new List <ScienceData> {
data
});
DumpData(data);
}
else if (CommNet.CommNetScenario.CommNetEnabled)
{
Utils.DisplayScreenMsg(Localizer.Format("#autoLOC_237738"));
}
else
{
Utils.DisplayScreenMsg(Localizer.Format("#autoLOC_237740"));
}
//UpdateUI();
}
private void AddTransmitter()
{
if (mTransmitterConfig == null || !mTransmitterConfig.HasValue("name"))
{
return;
}
var transmitters = part.FindModulesImplementing <IScienceDataTransmitter>();
if (transmitters.Count > 0)
{
RTLog.Notify("ModuleRTAntenna: Find TRANSMITTER success.");
mTransmitter = transmitters.First();
}
else
{
var copy = new ConfigNode();
mTransmitterConfig.CopyTo(copy);
part.AddModule(copy);
AddTransmitter();
RTLog.Notify("ModuleRTAntenna: Add TRANSMITTER success.");
// Trigger onVesselWasModified after adding a new transmitter
GameEvents.onVesselWasModified.Fire(this.part.vessel);
}
if (mTransmitter != null)
{
//overwrite default parameters of ModuleRTDataTransmitter
(mTransmitter as ModuleRTDataTransmitter).PacketSize = RTPacketSize;
(mTransmitter as ModuleRTDataTransmitter).PacketInterval = RTPacketInterval;
(mTransmitter as ModuleRTDataTransmitter).PacketResourceCost = RTPacketResourceCost;
}
GUI_SciencePacketInterval = String.Format("{0} sec", RTPacketInterval);
GUI_SciencePacketSize = String.Format("{0} Mits", RTPacketSize);
GUI_SciencePacketCost = String.Format("{0} charge", RTPacketResourceCost);
}
private void AddTransmitter()
{
if (mTransmitterConfig == null || !mTransmitterConfig.HasValue("name"))
{
return;
}
var transmitters = part.FindModulesImplementing <IScienceDataTransmitter>();
if (transmitters.Count > 0)
{
RTLog.Notify("ModuleRTAntenna: Find TRANSMITTER success.");
mTransmitter = transmitters.First();
}
else
{
var copy = new ConfigNode();
mTransmitterConfig.CopyTo(copy);
part.AddModule(copy);
AddTransmitter();
RTLog.Notify("ModuleRTAntenna: Add TRANSMITTER success.");
// Trigger onVesselWasModified after adding a new transmitter
GameEvents.onVesselWasModified.Fire(this.part.vessel);
}
}
private void RemoveTransmitter()
{
RTLog.Notify("ModuleRTAntennaPassive: Remove TRANSMITTER success.");
if (mTransmitter == null) return;
part.RemoveModule((PartModule) mTransmitter);
mTransmitter = null;
}
private void AddTransmitter()
{
if (mTransmitterConfig == null || !mTransmitterConfig.HasValue("name")) return;
var transmitters = part.FindModulesImplementing<IScienceDataTransmitter>();
if (transmitters.Count > 0)
{
RTLog.Notify("ModuleRTAntennaPassive: Find TRANSMITTER success.");
mTransmitter = transmitters.First();
}
else
{
var copy = new ConfigNode();
mTransmitterConfig.CopyTo(copy);
part.AddModule(copy);
AddTransmitter();
RTLog.Notify("ModuleRTAntennaPassive: Add TRANSMITTER success.");
}
}
protected void SelectAntenna()
{
// find an antenna
LogFormatted_DebugOnly("RealScience: SelectAntenna: Searching for a transmitter");
List<IScienceDataTransmitter> antennas = part.vessel.FindPartModulesImplementing<IScienceDataTransmitter>();
LogFormatted_DebugOnly(String.Format("RealScience: SelectAntenna: Found {0} antennas", antennas.Count));
float dataRate = 0f;
double resourceCost = double.MaxValue;
bool favorLowPowerAntenna = true;
if (RealScienceManager.Instance != null)
favorLowPowerAntenna = RealScienceManager.Instance.userSettings.favorLowPowerAntenna;
foreach(IScienceDataTransmitter transmitter in antennas)
{
if (favorLowPowerAntenna)
{
if (transmitter.DataResourceCost < resourceCost)
{
resourceCost = transmitter.DataResourceCost;
chosenTransmitter = transmitter;
}
}
else
{
if (transmitter.DataRate > dataRate)
{
dataRate = transmitter.DataRate;
chosenTransmitter = transmitter;
}
}
}
}
private bool transmitData(SEP_ExperimentHandler exp, int level, float submittedData, float newData)
{
ScienceData data = SEP_Utilities.getScienceData(exp, exp.getExperimentLevel(level), level);
if (exp.vessel.loaded)
{
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(exp.vessel);
if (bestTransmitter != null)
{
ScienceExperiment e = exp.getExperimentLevel(level);
float transmitterCost = getLoadedTransmitterCost(bestTransmitter);
float ecCost = newData * e.dataScale * transmitterCost;
if (ecCost > SEP_Utilities.getTotalVesselEC(exp.vessel))
{
if (!dataOnboard(exp, level))
{
SEP_Utilities.log("Not enough power for transmissionon this vessel: {1}; saving data: {0}", logLevels.log, data.title, exp.vessel.vesselName);
exp.addData(data);
if (exp.host != null)
{
exp.host.Events["ReviewDataEvent"].active = true;
exp.host.Events["TransferDataEvent"].active = exp.host.hasContainer;
exp.host.Events["CollectData"].active = true;
if (exp.host.Controller != null)
{
exp.host.Controller.setCollectEvent();
}
}
}
return(false);
}
SEP_Utilities.log("Sending data to vessel comms: {0}", logLevels.log, data.title);
bestTransmitter.TransmitData(new List <ScienceData> {
data
});
return(true);
}
else
{
if (!dataOnboard(exp, level))
{
SEP_Utilities.log("No Comms Devices on this vessel: {1}. Cannot Transmit Data; saving data: {0}", logLevels.log, data.title, exp.vessel.vesselName);
exp.addData(data);
if (exp.host != null)
{
exp.host.Events["ReviewDataEvent"].active = true;
exp.host.Events["TransferDataEvent"].active = exp.host.hasContainer;
exp.host.Events["CollectData"].active = true;
if (exp.host.Controller != null)
{
exp.host.Controller.setCollectEvent();
}
}
}
return(false);
}
}
else
{
List <ProtoPartSnapshot> transmitters = getProtoTransmitters(exp.vessel.protoVessel);
float?transmitterCost = getBestTransmitterCost(transmitters);
if (transmitterCost == null)
{
if (!dataOnboard(exp, level))
{
SEP_Utilities.log("No Comms Devices on this vessel: {1}. Cannot Transmit Data; saving data: {0}", logLevels.log, data.title, exp.vessel.protoVessel.vesselName);
exp.addData(data);
}
return(false);
}
//SEP_Utilities.log("Transmission Score: {0:N4}EC", logLevels.warning, transmitterCost);
ScienceExperiment e = exp.getExperimentLevel(level);
float ecCost = newData * e.dataScale * (float)transmitterCost;
//SEP_Utilities.log("Transmission Cost: {0:N4}EC", logLevels.warning, ecCost);
if (ecCost > SEP_Utilities.getTotalVesselEC(exp.vessel.protoVessel))
{
if (!dataOnboard(exp, level))
{
SEP_Utilities.log("Not enough electricity on this vessel: {1}. Cannot Transmit Data; saving data: {0}", logLevels.log, data.title, exp.vessel.protoVessel.vesselName);
exp.addData(data);
}
return(false);
}
ScienceSubject sub = SEP_Utilities.checkAndUpdateRelatedSubjects(exp, level, newData, submittedData);
if (sub == null)
{
return(false);
}
ResearchAndDevelopment.Instance.SubmitScienceData(newData * sub.dataScale, sub, 1, exp.vessel.protoVessel);
if (exp.vessel.HasValidContractObjectives(new List <string> {
"Generator"
}))
{
consumeResources(exp.vessel.protoVessel, ecCost);
}
exp.submittedData += (newData - submittedData);
return(true);
}
}
private void RemoveTransmitter()
{
RTLog.Notify("ModuleRTAntenna: Remove TRANSMITTER success.");
if (mTransmitter == null) return;
part.RemoveModule((PartModule) mTransmitter);
mTransmitter = null;
// Trigger onVesselWasModified after removing the transmitter
GameEvents.onVesselWasModified.Fire(this.part.vessel);
}
private void AddTransmitter()
{
if (mTransmitterConfig == null || !mTransmitterConfig.HasValue("name")) return;
var transmitters = part.FindModulesImplementing<IScienceDataTransmitter>();
if (transmitters.Count > 0)
{
RTLog.Notify("ModuleRTAntenna: Find TRANSMITTER success.");
mTransmitter = transmitters.First();
}
else
{
var copy = new ConfigNode();
mTransmitterConfig.CopyTo(copy);
part.AddModule(copy);
AddTransmitter();
RTLog.Notify("ModuleRTAntenna: Add TRANSMITTER success.");
// Trigger onVesselWasModified after adding a new transmitter
GameEvents.onVesselWasModified.Fire(this.part.vessel);
}
}
private void transferToVessel(ScienceRelayData RelayData)
{
if (resultsDialog != null)
{
resultsDialog.Dismiss();
}
if (RelayData._host == null || RelayData._data == null || RelayData._target == null || RelayData._source == null)
{
return;
}
List <ScienceRelayData> data = new List <ScienceRelayData>();
if (transferAll)
{
for (int i = resultsDialog.pages.Count - 1; i >= 0; i--)
{
ExperimentResultDialogPage page = resultsDialog.pages[i];
if (page == null)
{
continue;
}
if (page.pageData == null)
{
continue;
}
if (page.host == null)
{
continue;
}
ScienceRelayData relayData = new ScienceRelayData()
{
_data = page.pageData,
_host = page.host,
_boost = signalBoost(RelayData._boost + 1, RelayData._target, page.pageData, page.xmitDataScalar),
_target = RelayData._target,
_source = RelayData._source,
};
relayData._data.baseTransmitValue = page.xmitDataScalar;
data.Add(relayData);
}
}
else
{
RelayData._data.baseTransmitValue = currentPage.xmitDataScalar;
data.Add(RelayData);
}
for (int i = data.Count - 1; i >= 0; i--)
{
ScienceData d = data[i]._data;
Part host = data[i]._host;
List <IScienceDataContainer> containers = host.FindModulesImplementing <IScienceDataContainer>();
IScienceDataContainer hostContainer = null;
for (int j = containers.Count - 1; j >= 0; j--)
{
hostContainer = null;
IScienceDataContainer container = containers[j];
if (container == null)
{
continue;
}
ScienceData[] containerData = container.GetData();
for (int k = containerData.Length - 1; k >= 0; k--)
{
ScienceData dat = containerData[k];
if (dat.subjectID == d.subjectID)
{
hostContainer = container;
break;
}
}
if (hostContainer != null)
{
break;
}
}
IScienceDataTransmitter bestTransmitter = ScienceUtil.GetBestTransmitter(RelayData._source.FindPartModulesImplementing <IScienceDataTransmitter>());
if (bestTransmitter == null)
{
if (CommNetScenario.CommNetEnabled)
{
ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_238505"), 3, ScreenMessageStyle.UPPER_CENTER);
}
else
{
ScreenMessages.PostScreenMessage(Localizer.Format("#autoLOC_238507"), 3, ScreenMessageStyle.UPPER_CENTER);
}
}
else
{
d.triggered = true;
bestTransmitter.TransmitData(new List <ScienceData> {
d
});
queuedData.Add(data[i]);
if (hostContainer != null)
{
hostContainer.DumpData(d);
}
}
}
}
