text:
using System;
using System.Collections.Generic;
using System.Windows.Forms;
//Threading
using System.Threading;
//Localization
using System.Resources;
//Version
using System.Reflection;
//Busylight
using Busylight;
using System.Drawing;
//Sound
using System.Media;
//Skype
using Microsoft.Lync.Model;

namespace IcingaBusylightAgent
{
    static class Program
    {
        /// <summary>
        /// Der Haupteinstiegspunkt für die Anwendung.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new AgentContext());
        }
    }

    //TrayIcon context
    public class AgentContext : ApplicationContext
    {
        //Some variables
        private NotifyIcon trayIcon;
        private Thread dataThread;
        private Icinga2Client workerObject;
        private Dictionary<int, string> dictStates = new Dictionary<int, string>();
        private Dictionary<int, string> dictStatesHost = new Dictionary<int, string>();
        private Dictionary<int, ToolTipIcon> dictIcons = new Dictionary<int, ToolTipIcon>() {
            { 0, ToolTipIcon.Info },
            { 1, ToolTipIcon.Warning },
            { 2, ToolTipIcon.Error },
            { 3, ToolTipIcon.None }
        };

        //Data result
        private Dictionary<string, int> failHosts = new Dictionary<string, int>();
        private Dictionary<string, List<string>> failServices = new Dictionary<string, List<string>>();

        //Color variables
        Color color_up_ok;
        Color color_unreach_warn;
        Color color_down_crit;
        Color color_unknown;
        private Dictionary<int, Busylight.BusylightColor> dictColor = new Dictionary<int, Busylight.BusylightColor>();
        private Dictionary<int, Busylight.BusylightColor> dictColorHost = new Dictionary<int, Busylight.BusylightColor>();

        //Notification variables
        BusylightJingleClip sound;
        BusylightVolume volume;
        private string sound_file;
        private SoundPlayer player;

        //Skype for business
        private LyncClient lyncClient;
        private Dictionary<ContactAvailability, BusylightColor> dictSkypeColor = new Dictionary<ContactAvailability, BusylightColor>()
        {
            { ContactAvailability.Free, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_online.R, GreenRgbValue = Properties.Settings.Default.skype_online.G, BlueRgbValue = Properties.Settings.Default.skype_online.B } },
            { ContactAvailability.FreeIdle, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_away.R, GreenRgbValue = Properties.Settings.Default.skype_away.G, BlueRgbValue = Properties.Settings.Default.skype_away.B } },
            { ContactAvailability.Away, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_away.R, GreenRgbValue = Properties.Settings.Default.skype_away.G, BlueRgbValue = Properties.Settings.Default.skype_away.B } },
            { ContactAvailability.TemporarilyAway, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_away.R, GreenRgbValue = Properties.Settings.Default.skype_away.G, BlueRgbValue = Properties.Settings.Default.skype_away.B } },
            { ContactAvailability.Busy, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_busy.R, GreenRgbValue = Properties.Settings.Default.skype_busy.G, BlueRgbValue = Properties.Settings.Default.skype_busy.B } },
            { ContactAvailability.BusyIdle, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_busy.R, GreenRgbValue = Properties.Settings.Default.skype_busy.G, BlueRgbValue = Properties.Settings.Default.skype_busy.B } },
            { ContactAvailability.DoNotDisturb, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_dnd.R, GreenRgbValue = Properties.Settings.Default.skype_dnd.G, BlueRgbValue = Properties.Settings.Default.skype_dnd.B } },
            { ContactAvailability.Offline, new BusylightColor { RedRgbValue = Properties.Settings.Default.skype_other.R, GreenRgbValue = Properties.Settings.Default.skype_other.G, BlueRgbValue = Properties.Settings.Default.skype_other.B } }
        };

        //Translate _all_ the strings!
        ResourceManager rm = Strings.ResourceManager;

        private void showTip(string title, string message, ToolTipIcon icon)
        {
            //Show baloon tooltip
            trayIcon.BalloonTipTitle = title;
            trayIcon.BalloonTipText = message;
            trayIcon.BalloonTipIcon = icon;
            trayIcon.ShowBalloonTip(5000);
        }

        private void updateTime(bool inProgress=false)
        {
            if (inProgress == true)
            {
                //Update in progress
                trayIcon.ContextMenu.MenuItems[1].Text = string.Format("{0} ({1})", rm.GetString("mnu_update"), rm.GetString("mnu_update_progress"));
            }
            else
            {
                //Set last update
                trayIcon.ContextMenu.MenuItems[1].Text = string.Format("{0} ({1} {2})", rm.GetString("mnu_update"), rm.GetString("mnu_update_last"), DateTime.Now.ToString("HH:mm"));
            }
        }

        public AgentContext()
        {
            //Import state strings
            dictStates.Add(0, rm.GetString("state_0"));
            dictStates.Add(1, rm.GetString("state_1"));
            dictStates.Add(2, rm.GetString("state_2"));
            dictStates.Add(3, rm.GetString("state_3"));
            dictStatesHost.Add(0, rm.GetString("state_0"));
            dictStatesHost.Add(1, rm.GetString("state_2"));
            dictStatesHost.Add(2, rm.GetString("state_2"));
            dictStatesHost.Add(3, rm.GetString("state_2"));

            //Import color settings
            color_up_ok = Properties.Settings.Default.color_up_ok;
            color_unreach_warn = Properties.Settings.Default.color_unreach_warn;
            color_down_crit = Properties.Settings.Default.color_down_crit;
            color_unknown = Properties.Settings.Default.color_unknown;
            dictColor.Add(0, new BusylightColor
            {
                RedRgbValue = color_up_ok.R,
                GreenRgbValue = color_up_ok.G,
                BlueRgbValue = color_up_ok.B
            });
            dictColor.Add(1, new BusylightColor
            {
                RedRgbValue = color_unreach_warn.R,
                GreenRgbValue = color_unreach_warn.G,
                BlueRgbValue = color_unreach_warn.B
            });
            dictColor.Add(2, new BusylightColor
            {
                RedRgbValue = color_down_crit.R,
                GreenRgbValue = color_down_crit.G,
                BlueRgbValue = color_down_crit.B
            });
            dictColor.Add(3, new BusylightColor
            {
                RedRgbValue = color_unknown.R,
                GreenRgbValue = color_unknown.G,
                BlueRgbValue = color_unknown.B
            });
            dictColorHost.Add(0, new BusylightColor
            {
                RedRgbValue = color_up_ok.R,
                GreenRgbValue = color_up_ok.G,
                BlueRgbValue = color_up_ok.B
            });
            dictColorHost.Add(1, new BusylightColor
            {
                RedRgbValue = color_down_crit.R,
                GreenRgbValue = color_down_crit.G,
                BlueRgbValue = color_down_crit.B
            });
            dictColorHost.Add(2, new BusylightColor
            {
                RedRgbValue = color_down_crit.R,
                GreenRgbValue = color_down_crit.G,
                BlueRgbValue = color_down_crit.B
            });
            dictColorHost.Add(3, new BusylightColor
            {
                RedRgbValue = color_down_crit.R,
                GreenRgbValue = color_down_crit.G,
                BlueRgbValue = color_down_crit.B
            });

            //Import sound settings
            sound = Properties.Settings.Default.sound;
            volume = Properties.Settings.Default.sound_volume;
            sound_file = Properties.Settings.Default.sound_file;

            //Initialize tray icon
            trayIcon = new NotifyIcon()
            {
                Icon = Properties.Resources.icinga,
                ContextMenu = new ContextMenu(
                        new MenuItem[] {
                            new MenuItem(rm.GetString("mnu_configure"), configure),
                            new MenuItem(rm.GetString("mnu_update"), update),
                            new MenuItem("-"),
                            new MenuItem(rm.GetString("mnu_about"), about),
                            new MenuItem(rm.GetString("mnu_exit"), exit)
                        }
                    ),
                Visible = true,
                Text = "Icinga Busylight Agent"
            };

            //Start data thread
            initializeThread();

            //Show tool-tip
            Assembly assem = Assembly.GetEntryAssembly();
            AssemblyName assemName = assem.GetName();
            Version ver = assemName.Version;
            if (Properties.Settings.Default.balloon_enable_start == true)
            {
                showTip(rm.GetString("welcome_title"),
                    "Icinga Busylight Agent " + ver.ToString() + " " +
                rm.GetString("welcome_message"), ToolTipIcon.Info);
            }

            //Initialize log
            SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Application startup completed at {0}", DateTime.Now.ToString()), Properties.Settings.Default.log_level, 2);
        }

        void initializeThread()
        {
            //Create and (re-)start data thread
            workerObject = new Icinga2Client(
                Properties.Settings.Default.icinga_url,
                Properties.Settings.Default.icinga_user,
                Properties.Settings.Default.icinga_pass,
                (Properties.Settings.Default.icinga_update_interval * 1000 * 60)
                );

            //Set hostgroup filter
            if (Properties.Settings.Default.icinga_hostgroups.Length > 0)
            {
                workerObject.setHostgroups(Properties.Settings.Default.icinga_hostgroups.Split(';'));
            }

            //Update _all_ the data
            dataThread = new Thread(workerObject.updateData);
            //Set update event
            workerObject.complete += WorkerObject_complete;
            workerObject.inProgress += WorkerObject_inProgress;
        }

        private void WorkerObject_inProgress()
        {
            //Update in progress
            trayIcon.Icon = Properties.Resources.icinga_update;
            updateTime(true);
        }

        private void WorkerObject_complete(Dictionary<string, int> hosts, Dictionary<string, List<string>> services)
        {
            SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, "Data update retrieved by UI class", Properties.Settings.Default.log_level, 2);
            trayIcon.Icon = Properties.Resources.icinga;
            //Set data and alert failures
            failHosts = hosts;
            failServices = services;
            updateTime();
            alertInventory();
        }

        private void annoyUser(BusylightColor myColor)
        {
            //Play sound
            if (this.sound_file != "")
            {
                player = new SoundPlayer(sound_file);
                player.Play();
            }

            //Flash Busylight and play sound
            var controller = new Busylight.SDK();
            controller.Jingle(myColor, sound, volume);
            Thread.Sleep(5000);
            controller.Terminate();
        }

        private void alertInventory()
        {
            //Scans the inventory and alerts
            if (failHosts.Count + failServices.Count > Properties.Settings.Default.spam_thres)
            {
                //The shit just hit the fan, gross!
                showTip(rm.GetString("balloon_chaos_title"),
                    rm.GetString("balloon_chaos_msg").Replace("X", failHosts.Count.ToString())
                    .Replace("Y", failServices.Count.ToString()),
                    ToolTipIcon.Warning);
            }
            else
            {

                //Hosts
                try
                {
                    foreach (string host in failHosts.Keys)
                    {
                        if (Properties.Settings.Default.balloon_enable == true)
                        {
                            //Show tooltip if enabled
                            showTip(string.Format("Host {0}", dictStatesHost[failHosts[host]].ToUpper()), string.Format("Host '{0}' {1}", host, dictStatesHost[failHosts[host]]), ToolTipIcon.Error);
                        }

                        SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode,
                            string.Format("Alarm: Host '{0}' is '{1}'", host, dictStatesHost[failHosts[host]]),
                            Properties.Settings.Default.log_level, 2);

                        annoyUser(dictColorHost[failHosts[host]]);
                    }

                    //Services
                    foreach (string host in failServices.Keys)
                    {
                        //Only report if host not generally down
                        if(failHosts.ContainsKey(host) == false)
                        {
                            SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode,
                                string.Format("Host '{0}' not blacklisted!", host),
                                Properties.Settings.Default.log_level, 2);

                            //Report service
                            foreach (string service in failServices[host])
                            {
                                try
                                {
                                    //Extract state and service
                                    int thisState = Convert.ToInt32(service.Substring(service.IndexOf(';') + 1));
                                    string thisService = service.Substring(service.IndexOf('!') + 1);
                                    thisService = thisService.Substring(0, thisService.IndexOf(';'));

                                    SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode,
                                        string.Format("Alarm: '{0}' on '{1}' is '{2}'", thisService, host, dictStates[thisState]),
                                        Properties.Settings.Default.log_level, 2);

                                    //Show tooltip if enabled
                                    if (Properties.Settings.Default.balloon_enable == true)
                                    {
                                        showTip(string.Format("Service {0}", dictStates[thisState].ToUpper()),
                                        string.Format("Service '{0}' {1} '{2}' {3}", thisService, rm.GetString("state_on"), host, dictStates[thisState]), dictIcons[thisState]);
                                    }

                                    annoyUser(dictColor[thisState]);
                                }
                                catch (FormatException e)
                                {
                                    //Format error
                                    SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Format error: '{0}'", e.Message), Properties.Settings.Default.log_level, 2);
                                }
                            }
                        }
                        else
                        {
                            //Ignoring host
                            SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Ignoring host '{0}' as it's down", host), Properties.Settings.Default.log_level, 2);
                        }
                    }
                }
                catch (InvalidOperationException e)
                {
                    SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Invalid operation: '{0}'", e.Message), Properties.Settings.Default.log_level, 2);
                }

                //Reset Lync/SfB state if enabled
                if(Properties.Settings.Default.lync_enable == true)
                {
                    SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, "Resetting Lync/SfB state...", Properties.Settings.Default.log_level, 2);
                    try
                    {
                        lyncClient = LyncClient.GetClient();
                        if (lyncClient.State == ClientState.SignedIn)
                        {
                            //Read state
                            ContactAvailability myAvailability = (ContactAvailability)lyncClient.Self.Contact.GetContactInformation(ContactInformationType.Availability);
                            SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Lync/SfB state is '{0}'", myAvailability.ToString()), Properties.Settings.Default.log_level, 2);
                            //Set color
                            var controller = new Busylight.SDK();
                            controller.Light(dictSkypeColor[myAvailability]);
                        }
                    }
                    catch(System.Runtime.InteropServices.MarshalDirectiveException e)
                    {
                        SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Unable to read Lync/SfB state: '{0}'", e.Message), Properties.Settings.Default.log_level, 0);
                    }
                    catch (Exception e)
                    {
                        SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Unable to read Lync/SfB state: '{0}'", e.Message), Properties.Settings.Default.log_level, 0);
                    }
                }
            }
        }

        private void update(object sender, EventArgs e)
        {
            //Update data thread
            try
            {
                SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Thread state is: '{0}'", dataThread.ThreadState), Properties.Settings.Default.log_level, 2);
                if (dataThread.ThreadState == ThreadState.WaitSleepJoin || dataThread.ThreadState == ThreadState.Running)
                {
                    //already running
                    MessageBox.Show(rm.GetString("msgbox_update_running"), rm.GetString("msgbox_error"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                else if (dataThread.ThreadState == ThreadState.Stopped)
                {
                    //Start over
                    dataThread = new Thread(workerObject.updateData);
                    dataThread.Start();
                }
                else { dataThread.Start(); }
                }
            catch(ThreadStateException exc)
            {
                SimpleLoggerHelper.Log(Properties.Settings.Default.log_mode, string.Format("Error with thread handling: '{0}'", exc.Message), Properties.Settings.Default.log_level, 2);
            }
        }

        private void about(object sender, EventArgs e)
        {
            //Show about dialog
            FormAbout form_about = new FormAbout();
            form_about.Show();
        }

        private void configure(object sender, EventArgs e)
        {
            //Show configuration dialog
            FormSettings form_conf = new FormSettings();
            var dialogResult = form_conf.ShowDialog();

            //Reload thread
            initializeThread();
        }

        private void exit(object sender, EventArgs e)
        {
            //Hide tray icon and die in a fire
            trayIcon.Visible = false;
            Application.Exit();
        }
    }
}


text:
<?php

namespace BaleenTest\Migrations\Migration\Options;

use Baleen\Migrations\Exception\InvalidArgumentException;
use Baleen\Migrations\Migration\Options\Direction;
use Baleen\Migrations\Delta\DeltaId;
use BaleenTest\Migrations\BaseTestCase;
use Mockery as m;

/**
 * Class DirectionTest
 * @author Gabriel Somoza <gabriel@strategery.io>
 */
class DirectionTest extends BaseTestCase
{
    /**
     * testWithDirectionExceptionIfNotAllowed
     */
    public function testConstructorInvalidArgument()
    {
        $this->setExpectedException(InvalidArgumentException::class);
        new Direction('foo');
    }

    /**
     * testConstructorInteger
     * @return void
     */
    public function testConstructorInteger()
    {
        $this->assertTrue((new Direction(1))->isUp());
        $this->assertTrue((new Direction(-1))->isDown());
    }

    /**
     * testIsSameValueAs
     * @return void
     */
    public function testIsSameValueAs()
    {
        $d1 = new Direction(1);
        $d2 = new Direction(2);
        $d3 = new Direction(-1);
        $id = new DeltaId('v1');

        $this->assertTrue($d1->isSameValueAs($d2));
        $this->assertFalse($d2->isSameValueAs($d3));
        $this->assertFalse($d3->isSameValueAs($d1));
        $this->assertFalse($d1->isSameValueAs($id));
    }

    /**
     * testToString
     * @return void
     */
    public function testToString()
    {
        $up = Direction::up();
        $down = Direction::down();
        $this->assertSame(Direction::UP, (string) $up);
        $this->assertSame(Direction::DOWN, (string) $down);
    }
}

redpajama_set_name: RedPajamaGithub


text:
using Livet;

namespace Movselex.Core.Models
{
    internal class ProgressInfo : NotificationObject, IProgressInfo
    {
        #region IsProgressing•ÏX'Ê'mƒvƒƒpƒeƒB

        private bool _isProgressing;

        public bool IsProgressing
        {
            get { return _isProgressing; }
            set
            {
                if (_isProgressing == value) return;
                _isProgressing = value;
                if (!value) ProgressMessage = "";
                RaisePropertyChanged();
            }
        }

        #endregion

        #region ProgressMessage•ÏX'Ê'mƒvƒƒpƒeƒB

        private string _progressMessage;

        public string ProgressMessage
        {
            get { return _progressMessage; }
            set
            {
                if (_progressMessage == value) return;
                _progressMessage = value;
                RaisePropertyChanged();
            }
        }

        #endregion

        public void UpdateProgress(bool isProgressing)
        {
            IsProgressing = isProgressing;
            ProgressMessage = "";
        }

        public void SetProgressMessage(string message)
        {
            ProgressMessage = message;
        }

        public void UpdateProgressMessage(string message, string detail, int now, int last)
        {
            SetProgressMessage(string.Format("{0}... {1} ({2} / {3})", message, detail ?? "", now, last));
        }

    }
}


text:
'''
Basic accelerometer example.
'''

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.clock import Clock

from plyer import accelerometer

class AccelerometerTest(BoxLayout):
    def __init__(self):
        super().__init__()
        self.sensorEnabled = False

    def do_toggle(self):
        try:
            if not self.sensorEnabled:
                accelerometer.enable()
                Clock.schedule_interval(self.get_acceleration, 1 / 20.)

                self.sensorEnabled = True
                self.ids.toggle_button.text = "Stop Accelerometer"
            else:
                accelerometer.disable()
                Clock.unschedule(self.get_acceleration)

                self.sensorEnabled = False
                self.ids.toggle_button.text = "Start Accelerometer"
        except NotImplementedError:
            import traceback
            traceback.print_exc()
            status = "Accelerometer is not implemented for your platform"
            self.ids.accel_status.text = status

    def get_acceleration(self, dt):
        val = accelerometer.acceleration[:3]

        if not val == (None, None, None):
            self.ids.x_label.text = "X: " + str(val[0])
            self.ids.y_label.text = "Y: " + str(val[1])
            self.ids.z_label.text = "Z: " + str(val[2])

class AccelerometerTestApp(App):
    def build(self):
        return AccelerometerTest()

    def on_pause(self):
        return True

if __name__ == '__main__':
    AccelerometerTestApp().run()


text:
namespace {

// Wrapper for the callback provided to
// CompositorMusConnection:OnWindowInputEvent. This tracks whether the it was
// called, along with the result.
class TestCallback : public base::RefCounted<TestCallback> {
 public:
  TestCallback() : called_(false), result_(false) {}

  bool called() { return called_; }
  bool result() { return result_; }

  void BoolCallback(bool result) {
    called_ = true;
    result_ = result;
  }

 private:
  friend class base::RefCounted<TestCallback>;

  ~TestCallback() {}

  bool called_;
  bool result_;

  DISALLOW_COPY_AND_ASSIGN(TestCallback);
};

// Allows for overriding the behaviour of HandleInputEvent, to simulate input
// handlers which consume events before they are sent to the renderer.
class TestInputHandlerManager : public content::InputHandlerManager {
 public:
  TestInputHandlerManager(
      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
      content::InputHandlerManagerClient* client,
      scheduler::RendererScheduler* renderer_scheduler)
      : InputHandlerManager(task_runner, client, nullptr, renderer_scheduler),
        override_result_(false),
        result_(content::InputEventAckState::INPUT_EVENT_ACK_STATE_UNKNOWN) {}
  ~TestInputHandlerManager() override {}

  // Stops overriding the behaviour of HandleInputEvent
  void ClearHandleInputEventOverride();

  // Overrides the behaviour of HandleInputEvent, returing |result|.
  void SetHandleInputEventResult(content::InputEventAckState result);

  // content::InputHandlerManager:
  content::InputEventAckState HandleInputEvent(
      int routing_id,
      const blink::WebInputEvent* input_event,
      ui::LatencyInfo* latency_info) override;

 private:
  // If true content::InputHandlerManager::HandleInputEvent is not called.
  bool override_result_;

  // The result to return in HandleInputEvent if |override_result_|.
  content::InputEventAckState result_;

  DISALLOW_COPY_AND_ASSIGN(TestInputHandlerManager);
};

void TestInputHandlerManager::ClearHandleInputEventOverride() {
  override_result_ = false;
}

void TestInputHandlerManager::SetHandleInputEventResult(
    content::InputEventAckState result) {
  override_result_ = true;
  result_ = result;
}

content::InputEventAckState TestInputHandlerManager::HandleInputEvent(
    int routing_id,
    const blink::WebInputEvent* input_event,
    ui::LatencyInfo* latency_info) {
  if (override_result_)
    return result_;
  return content::InputHandlerManager::HandleInputEvent(routing_id, input_event,
                                                        latency_info);
}

// Empty implementation of InputHandlerManagerClient.
class TestInputHandlerManagerClient
    : public content::InputHandlerManagerClient {
 public:
  TestInputHandlerManagerClient() {}
  ~TestInputHandlerManagerClient() override{};

  // content::InputHandlerManagerClient:
  void SetBoundHandler(const Handler& handler) override {}
  void DidAddInputHandler(int routing_id) override {}
  void DidRemoveInputHandler(int routing_id) override {}
  void DidOverscroll(int routing_id,
                     const content::DidOverscrollParams& params) override {}
  void DidStopFlinging(int routing_id) override {}
  void NotifyInputEventHandled(int routing_id,
                               blink::WebInputEvent::Type type) override {}

 private:
  DISALLOW_COPY_AND_ASSIGN(TestInputHandlerManagerClient);
};

// Implementation of RenderWidget for testing, performs no initialization.
class TestRenderWidget : public content::RenderWidget {
 public:
  explicit TestRenderWidget(content::CompositorDependencies* compositor_deps)
      : content::RenderWidget(compositor_deps,
                              blink::WebPopupTypeNone,
                              blink::WebScreenInfo(),
                              true,
                              false,
                              false) {}

 protected:
  ~TestRenderWidget() override {}

 private:
  DISALLOW_COPY_AND_ASSIGN(TestRenderWidget);
};

// Test override of RenderWidgetInputHandler to allow the control of
// HandleInputEvent. This will perform no actions on input until a
// RenderWidgetInputHandlerDelegate is set. Once set this will always ack
// received events.
class TestRenderWidgetInputHandler : public content::RenderWidgetInputHandler {
 public:
  TestRenderWidgetInputHandler(content::RenderWidget* render_widget);
  ~TestRenderWidgetInputHandler() override {}

  void set_delegate(content::RenderWidgetInputHandlerDelegate* delegate) {
    delegate_ = delegate;
  }
  void set_state(content::InputEventAckState state) { state_ = state; }

  // content::RenderWidgetInputHandler:
  void HandleInputEvent(const blink::WebInputEvent& input_event,
                        const ui::LatencyInfo& latency_info,
                        content::InputEventDispatchType dispatch_type) override;

 private:
  // The input delegate which receives event acks.
  content::RenderWidgetInputHandlerDelegate* delegate_;

  // The result of input handling to send to |delegate_| during the ack.
  content::InputEventAckState state_;

  DISALLOW_COPY_AND_ASSIGN(TestRenderWidgetInputHandler);
};

TestRenderWidgetInputHandler::TestRenderWidgetInputHandler(
    content::RenderWidget* render_widget)
    : content::RenderWidgetInputHandler(render_widget, render_widget),
      delegate_(nullptr),
      state_(content::InputEventAckState::INPUT_EVENT_ACK_STATE_UNKNOWN) {}

void TestRenderWidgetInputHandler::HandleInputEvent(
    const blink::WebInputEvent& input_event,
    const ui::LatencyInfo& latency_info,
    content::InputEventDispatchType dispatch_type) {
  if (delegate_) {
    scoped_ptr<content::InputEventAck> ack(
        new content::InputEventAck(input_event.type, state_));
    delegate_->OnInputEventAck(std::move(ack));
  }
}

}  // namespace

namespace content {

// Test suite for CompositorMusConnection, this does not setup a full renderer
// environment. This does not establish a connection to a mus server, nor does
// it initialize one.
class CompositorMusConnectionTest : public testing::Test {
 public:
  CompositorMusConnectionTest() {}
  ~CompositorMusConnectionTest() override {}

  // Returns a valid key event, so that it can be converted to a web event by
  // CompositorMusConnection.
  scoped_ptr<ui::Event> GenerateKeyEvent();

  // Calls CompositorMusConnection::OnWindowInputEvent.
  void OnWindowInputEvent(mus::Window* window,
                          const ui::Event& event,
                          scoped_ptr<base::Callback<void(bool)>>* ack_callback);

  // Confirms the state of pending tasks enqueued on each task runner, and runs
  // until idle.
  void VerifyAndRunQueues(bool main_task_runner_enqueued,
                          bool compositor_task_runner_enqueued);

  CompositorMusConnection* compositor_connection() {
    return compositor_connection_.get();
  }
  RenderWidgetMusConnection* connection() { return connection_; }
  TestInputHandlerManager* input_handler_manager() {
    return input_handler_manager_.get();
  }
  TestRenderWidgetInputHandler* render_widget_input_handler() {
    return render_widget_input_handler_.get();
  }

  // testing::Test:
  void SetUp() override;
  void TearDown() override;

 private:
  // Mocks/Fakes of the testing environment.
  TestInputHandlerManagerClient input_handler_manager_client_;
  FakeCompositorDependencies compositor_dependencies_;
  FakeRendererScheduler renderer_scheduler_;
  MockRenderThread render_thread_;
  scoped_refptr<TestRenderWidget> render_widget_;
  mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request_;

  // Not owned, RenderWidgetMusConnection tracks in static state. Cleared during
  // TearDown.
  RenderWidgetMusConnection* connection_;

  // Test versions of task runners, see VerifyAndRunQueues to use in testing.
  scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
  scoped_refptr<base::TestSimpleTaskRunner> compositor_task_runner_;

  // Actual CompositorMusConnection for testing.
  scoped_refptr<CompositorMusConnection> compositor_connection_;

  // Test implementations, to control input given to |compositor_connection_|.
  scoped_ptr<TestInputHandlerManager> input_handler_manager_;
  scoped_ptr<TestRenderWidgetInputHandler> render_widget_input_handler_;

  DISALLOW_COPY_AND_ASSIGN(CompositorMusConnectionTest);
};

scoped_ptr<ui::Event> CompositorMusConnectionTest::GenerateKeyEvent() {
  return scoped_ptr<ui::Event>(new ui::KeyEvent(
      ui::ET_KEY_PRESSED, ui::KeyboardCode::VKEY_A, ui::EF_NONE));
}

void CompositorMusConnectionTest::OnWindowInputEvent(
    mus::Window* window,
    const ui::Event& event,
    scoped_ptr<base::Callback<void(bool)>>* ack_callback) {
  compositor_connection_->OnWindowInputEvent(window, event, ack_callback);
}

void CompositorMusConnectionTest::VerifyAndRunQueues(
    bool main_task_runner_enqueued,
    bool compositor_task_runner_enqueued) {
  // Run through the enqueued actions.
  EXPECT_EQ(main_task_runner_enqueued, main_task_runner_->HasPendingTask());
  main_task_runner_->RunUntilIdle();

  EXPECT_EQ(compositor_task_runner_enqueued,
            compositor_task_runner_->HasPendingTask());
  compositor_task_runner_->RunUntilIdle();
}

void CompositorMusConnectionTest::SetUp() {
  testing::Test::SetUp();

  main_task_runner_ = new base::TestSimpleTaskRunner();
  compositor_task_runner_ = new base::TestSimpleTaskRunner();

  input_handler_manager_.reset(new TestInputHandlerManager(
      compositor_task_runner_, &input_handler_manager_client_,
      &renderer_scheduler_));

  const int routing_id = 42;
  compositor_connection_ = new CompositorMusConnection(
      routing_id, main_task_runner_, compositor_task_runner_,
      std::move(request_), input_handler_manager_.get());

  // CompositorMusConnection attempts to create connection to the non-existant
  // server. Clear that.
  compositor_task_runner_->ClearPendingTasks();

  render_widget_ = new TestRenderWidget(&compositor_dependencies_);
  render_widget_input_handler_.reset(
      new TestRenderWidgetInputHandler(render_widget_.get()));
  connection_ = RenderWidgetMusConnection::GetOrCreate(routing_id);
  connection_->SetInputHandler(render_widget_input_handler_.get());
}

void CompositorMusConnectionTest::TearDown() {
  // Clear static state.
  connection_->OnConnectionLost();
  testing::Test::TearDown();
}

// Tests that for events which the renderer will ack, yet not consume, that
// CompositorMusConnection consumes the ack during OnWindowInputEvent, and calls
// it with the correct state once processed.
TEST_F(CompositorMusConnectionTest, NotConsumed) {
  TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
  input_handler->set_delegate(connection());
  input_handler->set_state(
      InputEventAckState::INPUT_EVENT_ACK_STATE_NOT_CONSUMED);

  mus::TestWindow test_window;
  scoped_ptr<ui::Event> event(GenerateKeyEvent());
  scoped_refptr<TestCallback> test_callback(new TestCallback);
  scoped_ptr<base::Callback<void(bool)>> ack_callback(
      new base::Callback<void(bool)>(
          base::Bind(&::TestCallback::BoolCallback, test_callback)));

  OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
  // OnWindowInputEvent is expected to clear the callback if it plans on
  // handling the ack.
  EXPECT_FALSE(ack_callback.get());

  VerifyAndRunQueues(true, true);

  // The ack callback should have been called
  EXPECT_TRUE(test_callback->called());
  EXPECT_FALSE(test_callback->result());
}

// Tests that for events which the renderer will ack, and consume, that
// CompositorMusConnection consumes the ack during OnWindowInputEvent, and calls
// it with the correct state once processed.
TEST_F(CompositorMusConnectionTest, Consumed) {
  TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
  input_handler->set_delegate(connection());
  input_handler->set_state(InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);

  mus::TestWindow test_window;
  scoped_ptr<ui::Event> event(GenerateKeyEvent());
  scoped_refptr<TestCallback> test_callback(new TestCallback);
  scoped_ptr<base::Callback<void(bool)>> ack_callback(
      new base::Callback<void(bool)>(
          base::Bind(&::TestCallback::BoolCallback, test_callback)));

  OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
  // OnWindowInputEvent is expected to clear the callback if it plans on
  // handling the ack.
  EXPECT_FALSE(ack_callback.get());

  VerifyAndRunQueues(true, true);

  // The ack callback should have been called
  EXPECT_TRUE(test_callback->called());
  EXPECT_TRUE(test_callback->result());
}

// Tests that when the RenderWidgetInputHandler does not ack before a new event
// arrives, that only the most recent ack is fired.
TEST_F(CompositorMusConnectionTest, LostAck) {
  mus::TestWindow test_window;
  scoped_ptr<ui::Event> event1(GenerateKeyEvent());
  scoped_refptr<TestCallback> test_callback1(new TestCallback);
  scoped_ptr<base::Callback<void(bool)>> ack_callback1(
      new base::Callback<void(bool)>(
          base::Bind(&::TestCallback::BoolCallback, test_callback1)));

  OnWindowInputEvent(&test_window, *event1.get(), &ack_callback1);
  EXPECT_FALSE(ack_callback1.get());
  // When simulating the timeout the ack is never enqueued
  VerifyAndRunQueues(true, false);

  // Setting a delegate will lead to the next event being acked. Having a
  // cleared queue simulates the input handler timing out on an event.
  TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
  input_handler->set_delegate(connection());
  input_handler->set_state(InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);

  scoped_ptr<ui::Event> event2(GenerateKeyEvent());
  scoped_refptr<TestCallback> test_callback2(new TestCallback);
  scoped_ptr<base::Callback<void(bool)>> ack_callback2(
      new base::Callback<void(bool)>(
          base::Bind(&::TestCallback::BoolCallback, test_callback2)));
  OnWindowInputEvent(&test_window, *event2.get(), &ack_callback2);
  EXPECT_FALSE(ack_callback2.get());

  VerifyAndRunQueues(true, true);

  // Only the most recent ack was called.
  EXPECT_FALSE(test_callback1->called());
  EXPECT_TRUE(test_callback2->called());
  EXPECT_TRUE(test_callback2->result());
}

// Tests that when an input handler consumes the event, that
// CompositorMusConnection does not consume the ack, nor calls it.
TEST_F(CompositorMusConnectionTest, InputHandlerConsumes) {
  input_handler_manager()->SetHandleInputEventResult(
      InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
  mus::TestWindow test_window;
  scoped_ptr<ui::Event> event(GenerateKeyEvent());
  scoped_refptr<TestCallback> test_callback(new TestCallback);
  scoped_ptr<base::Callback<void(bool)>> ack_callback(
      new base::Callback<void(bool)>(
          base::Bind(&::TestCallback::BoolCallback, test_callback)));

  OnWindowInputEvent(&test_window, *event.get(), &ack_callback);

  EXPECT_TRUE(ack_callback.get());
  VerifyAndRunQueues(false, false);
  EXPECT_FALSE(test_callback->called());
}

// Tests that when the renderer will not ack an event, that
// CompositorMusConnection does not consume the ack, nor calls it.
TEST_F(CompositorMusConnectionTest, RendererWillNotSendAck) {
  mus::TestWindow test_window;
  ui::PointerEvent event(ui::ET_POINTER_DOWN,
                         ui::EventPointerType::POINTER_TYPE_MOUSE, gfx::Point(),
                         gfx::Point(), ui::EF_NONE, 0, ui::EventTimeForNow());

  scoped_refptr<TestCallback> test_callback(new TestCallback);
  scoped_ptr<base::Callback<void(bool)>> ack_callback(
      new base::Callback<void(bool)>(
          base::Bind(&::TestCallback::BoolCallback, test_callback)));

  OnWindowInputEvent(&test_window, event, &ack_callback);
  EXPECT_TRUE(ack_callback.get());

  VerifyAndRunQueues(true, false);
  EXPECT_FALSE(test_callback->called());
}

}  // namespace content


text:
using System;
using System.Collections.Generic;
using System.IO;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Engines;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;
using GemBox.Document;

[SimpleJob(RuntimeMoniker.Net48)]
[SimpleJob(RuntimeMoniker.NetCoreApp31)]
public class Program
{
    private DocumentModel document;
    private readonly Consumer consumer = new Consumer();

    public static void Main()
    {
        BenchmarkRunner.Run<Program>();
    }

    [GlobalSetup]
    public void SetLicense()
    {
        // If using Professional version, put your serial key below.
        ComponentInfo.SetLicense("FREE-LIMITED-KEY");

        // If using Free version and example exceeds its limitations, use Trial or Time Limited version:
        // https://www.gemboxsoftware.com/document/examples/free-trial-professional-modes/1301

        this.document = DocumentModel.Load("RandomSections.docx");
    }

    [Benchmark]
    public DocumentModel Reading()
    {
        return DocumentModel.Load("RandomSections.docx");
    }

    [Benchmark]
    public void Writing()
    {
        using (var stream = new MemoryStream())
            this.document.Save(stream, new DocxSaveOptions());
    }

    [Benchmark]
    public void Iterating()
    {
        this.LoopThroughAllElements().Consume(this.consumer);
    }

    public IEnumerable<Element> LoopThroughAllElements()
    {
        return this.document.GetChildElements(true);
    }
}


text:
/**
 * This class implements the component event domain. All classes extending from
 * {@link Ext.Component} are included in this domain. The matching criteria uses
 * {@link Ext.ComponentQuery}.
 *
 * @private
 */
Ext.define('Ext.app.domain.Component', {
    extend: 'Ext.app.EventDomain',
    singleton: true,

    requires: [
        'Ext.Widget'
    ],

    type: 'component',

    constructor: function() {
        this.callParent();

        this.monitor(Ext.Widget);
    },

    dispatch: function(target, ev, args) {
        var controller = target.lookupController(false), // don't skip target
            domain, view;

        while (controller) {
            domain = controller.compDomain;
            if (domain) {
                if (domain.dispatch(target, ev, args) === false) {
                    return false;
                }
            }
            view = controller.getView();
            controller = view ? view.lookupController(true) : null;
        }
        return this.callParent(arguments);
    },

    match: function(target, selector) {
        return target.is(selector);
    }
});


text:
'use strict';

var Util = require('../util/Util.js');

var LispFunction = function(LispValue, func) {
    LispValue.call(this, LispValue.FUNCTION, func);
    Util.inherits(LispFunction, LispValue, this);

    var builtin = !!func;
    var name = null; // unevaluated Symbol
    var funcScope = null; // Scope
    var parameters = null; // unevaluated SExpression
    var body = null; // unevaluated SExpression

    this.setBuiltin = function(flag) { builtin = flag; };
    this.isBuiltin = function() { return builtin; };

    this.setName = function(nam) { name = nam; };
    this.getName = function() { return name; };

    this.setScope = function(scope) { funcScope = scope; };
    this.getScope = function() { return funcScope; };

    this.setParameters = function(params) { parameters = params; };
    this.getParameters = function() { return parameters; };

    this.setBody = function(bod) { body = bod; };
    this.getBody = function() { return body; };

    // this.eval = function(_scope) { return this; }
    // Function always evaluates to LispFunction!

    this.clone = Util.extend(this.clone, function(clone) {
        clone.setBuiltin(builtin);
        clone.setName(name.clone());
        clone.setScope(funcScope);
        clone.setParameters(parameters ? parameters.clone() : undefined);
        clone.setBody(body ? body.clone() : undefined);
        return clone;
    }.bind(this));

    this.toString = function() {
        return '<%0function %1%2>'.fmt(
            builtin ? 'builtin ' : '',
            name.getValue(),
            builtin ? '' : ' ' + parameters.toString()
        );
    };

};

module.exports = LispFunction;


text:
! { dg-do compile }
!
! PR 41784: [OOP] ICE in load_derived_extensions
!
! Contributed by Salvatore Filippone <sfilippone@uniroma2.it>

module m
  type  :: A
  end type
  type, extends(A) :: B
  end type
end module

use m, only: A
end

! { dg-final { cleanup-modules "m" } }


text:
/*
* Base configs
*/
/*
* Grid
*/
/*
* Colours
*/
/**
* Tables
*/
/*! normalize.css v3.0.2 | MIT License | git.io/normalize */
/**
* 1. Set default font family to sans-serif.
* 2. Prevent iOS text size adjust after orientation change, without disabling
*    user zoom.
*/
ul, ol, dl {
margin: 0;
padding: 0;
}

html {
font-family: sans-serif;
/* 1 */
-ms-text-size-adjust: 100%;
/* 2 */
-webkit-text-size-adjust: 100%;
/* 2 */
}

/**
* Remove default margin.
*/
body {
margin: 0;
}

/* HTML5 display definitions
========================================================================== */
/**
* Correct `block` display not defined for any HTML5 element in IE 8/9.
* Correct `block` display not defined for `details` or `summary` in IE 10/11
* and Firefox.
* Correct `block` display not defined for `main` in IE 11.
*/
article,
aside,
details,
figcaption,
figure,
footer,
header,
hgroup,
main,
menu,
nav,
section,
summary {
display: block;
}

/**
* 1. Correct `inline-block` display not defined in IE 8/9.
* 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.
*/
audio,
canvas,
progress,
video {
display: inline-block;
/* 1 */
vertical-align: baseline;
/* 2 */
}

/**
* Prevent modern browsers from displaying `audio` without controls.
* Remove excess height in iOS 5 devices.
*/
audio:not([controls]) {
display: none;
height: 0;
}

/**
* Address `[hidden]` styling not present in IE 8/9/10.
* Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.
*/
[hidden],
template {
display: none;
}

/* Links
========================================================================== */
/**
* Remove the gray background color from active links in IE 10.
*/
a {
background-color: transparent;
}

/**
* Improve readability when focused and also mouse hovered in all browsers.
*/
a:active,
a:hover {
outline: 0;
}

/* Text-level semantics
========================================================================== */
/**
* Address styling not present in IE 8/9/10/11, Safari, and Chrome.
*/
abbr[title] {
border-bottom: 1px dotted;
}

/**
* Address style set to `bolder` in Firefox 4+, Safari, and Chrome.
*/
b,
strong {
font-weight: bold;
}

/**
* Address styling not present in Safari and Chrome.
*/
dfn {
font-style: italic;
}

/**
* Address variable `h1` font-size and margin within `section` and `article`
* contexts in Firefox 4+, Safari, and Chrome.
*/
h1 {
font-size: 2em;
margin: 0.67em 0;
}

/**
* Address styling not present in IE 8/9.
*/
mark {
background: #ff0;
color: #000;
}

/**
* Address inconsistent and variable font size in all browsers.
*/
small {
font-size: 80%;
}

/**
* Prevent `sub` and `sup` affecting `line-height` in all browsers.
*/
sub,
sup {
font-size: 75%;
line-height: 0;
position: relative;
vertical-align: baseline;
}

sup {
top: -0.5em;
}

sub {
bottom: -0.25em;
}

/* Embedded content
========================================================================== */
/**
* Remove border when inside `a` element in IE 8/9/10.
*/
img {
border: 0;
}

/**
* Correct overflow not hidden in IE 9/10/11.
*/
svg:not(:root) {
overflow: hidden;
}

/* Grouping content
========================================================================== */
/**
* Address margin not present in IE 8/9 and Safari.
*/
figure {
margin: 1em 40px;
}

/**
* Address differences between Firefox and other browsers.
*/
hr {
-moz-box-sizing: content-box;
box-sizing: content-box;
height: 0;
}

/**
* Contain overflow in all browsers.
*/
pre {
overflow: auto;
}

/**
* Address odd `em`-unit font size rendering in all browsers.
*/
code,
kbd,
pre,
samp {
font-family: monospace, monospace;
font-size: 1em;
}

/* Forms
========================================================================== */
/**
* Known limitation: by default, Chrome and Safari on OS X allow very limited
* styling of `select`, unless a `border` property is set.
*/
/**
* 1. Correct color not being inherited.
*    Known issue: affects color of disabled elements.
* 2. Correct font properties not being inherited.
* 3. Address margins set differently in Firefox 4+, Safari, and Chrome.
*/
button,
input,
optgroup,
select,
textarea {
color: inherit;
/* 1 */
font: inherit;
/* 2 */
margin: 0;
/* 3 */
}

/**
* Address `overflow` set to `hidden` in IE 8/9/10/11.
*/
button {
overflow: visible;
}

/**
* Address inconsistent `text-transform` inheritance for `button` and `select`.
* All other form control elements do not inherit `text-transform` values.
* Correct `button` style inheritance in Firefox, IE 8/9/10/11, and Opera.
* Correct `select` style inheritance in Firefox.
*/
button,
select {
text-transform: none;
}

/**
* 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
*    and `video` controls.
* 2. Correct inability to style clickable `input` types in iOS.
* 3. Improve usability and consistency of cursor style between image-type
*    `input` and others.
*/
button,
html input[type="button"],
input[type="reset"],
input[type="submit"] {
-webkit-appearance: button;
/* 2 */
cursor: pointer;
/* 3 */
}

/**
* Re-set default cursor for disabled elements.
*/
button[disabled],
html input[disabled] {
cursor: default;
}

/**
* Remove inner padding and border in Firefox 4+.
*/
button::-moz-focus-inner,
input::-moz-focus-inner {
border: 0;
padding: 0;
}

/**
* Address Firefox 4+ setting `line-height` on `input` using `!important` in
* the UA stylesheet.
*/
input {
line-height: normal;
}

/**
* It's recommended that you don't attempt to style these elements.
* Firefox's implementation doesn't respect box-sizing, padding, or width.
*
* 1. Address box sizing set to `content-box` in IE 8/9/10.
* 2. Remove excess padding in IE 8/9/10.
*/
input[type="checkbox"],
input[type="radio"] {
box-sizing: border-box;
/* 1 */
padding: 0;
/* 2 */
}

/**
* Fix the cursor style for Chrome's increment/decrement buttons. For certain
* `font-size` values of the `input`, it causes the cursor style of the
* decrement button to change from `default` to `text`.
*/
input[type="number"]::-webkit-inner-spin-button,
input[type="number"]::-webkit-outer-spin-button {
height: auto;
}

/**
* 1. Address `appearance` set to `searchfield` in Safari and Chrome.
* 2. Address `box-sizing` set to `border-box` in Safari and Chrome
*    (include `-moz` to future-proof).
*/
input[type="search"] {
-webkit-appearance: textfield;
/* 1 */
-moz-box-sizing: content-box;
-webkit-box-sizing: content-box;
/* 2 */
box-sizing: content-box;
}

/**
* Remove inner padding and search cancel button in Safari and Chrome on OS X.
* Safari (but not Chrome) clips the cancel button when the search input has
* padding (and `textfield` appearance).
*/
input[type="search"]::-webkit-search-cancel-button,
input[type="search"]::-webkit-search-decoration {
-webkit-appearance: none;
}

/**
* Define consistent border, margin, and padding.
*/
fieldset {
border: 1px solid #c0c0c0;
margin: 0 2px;
padding: 0.35em 0.625em 0.75em;
}

/**
* 1. Correct `color` not being inherited in IE 8/9/10/11.
* 2. Remove padding so people aren't caught out if they zero out fieldsets.
*/
legend {
border: 0;
/* 1 */
padding: 0;
/* 2 */
}

/**
* Remove default vertical scrollbar in IE 8/9/10/11.
*/
textarea {
overflow: auto;
}

/**
* Don't inherit the `font-weight` (applied by a rule above).
* NOTE: the default cannot safely be changed in Chrome and Safari on OS X.
*/
optgroup {
font-weight: bold;
}

/* Tables
========================================================================== */
/**
* Remove most spacing between table cells.
*/
table {
border-collapse: collapse;
border-spacing: 0;
}

td,
th {
padding: 0;
}

/*! jQuery UI - v1.11.4 - 2016-06-30
* http://jqueryui.com
* Includes: core.css, autocomplete.css, menu.css
* Copyright jQuery Foundation and other contributors; Licensed MIT */
/**
* MODIFIED BY AVOCOSECURE.
* UPDATED .ui-menu, .ui-menu .ui-menu-item
* REMOVED .ui-state-focus, ui-state-active
*/
.ui-helper-hidden {
display: none;
}

.ui-helper-hidden-accessible {
border: 0;
clip: rect(0 0 0 0);
height: 1px;
margin: -1px;
overflow: hidden;
padding: 0;
position: absolute;
width: 1px;
}

.ui-helper-reset {
margin: 0;
padding: 0;
border: 0;
outline: 0;
line-height: 1.3;
text-decoration: none;
font-size: 100%;
list-style: none;
}

.ui-helper-clearfix:before, .ui-helper-clearfix:after {
content: "";
display: table;
border-collapse: collapse;
}

.ui-helper-clearfix:after {
clear: both;
}

.ui-helper-clearfix {
min-height: 0;
}

.ui-helper-zfix {
width: 100%;
height: 100%;
top: 0;
left: 0;
position: absolute;
opacity: 0;
filter: Alpha(Opacity=0);
}

.ui-front {
z-index: 100;
}

.ui-state-disabled {
cursor: default !important;
}

.ui-icon {
display: block;
text-indent: -99999px;
overflow: hidden;
background-repeat: no-repeat;
}

.ui-widget-overlay {
position: fixed;
top: 0;
left: 0;
width: 100%;
height: 100%;
}

.ui-autocomplete {
position: absolute;
top: 0;
left: 0;
cursor: default;
}

.ui-menu {
background-color: #FFF;
list-style: none;
padding: 3px 0 0 3px;
border: #BCBDBF 1px solid;
margin: 3px 0 0 0;
display: block;
outline: none;
}

.ui-menu .ui-menu {
position: absolute;
}

.ui-menu .ui-menu-item {
position: relative;
margin: 0;
padding: 3px 12.8px 3px 12.8px;
cursor: pointer;
min-height: 0;
list-style-image: url("data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7");
}

.ui-menu .ui-menu-divider {
margin: 5px 0;
height: 0;
font-size: 0;
line-height: 0;
border-width: 1px 0 0 0;
}

.ui-menu-icons {
position: relative;
}

.ui-menu-icons .ui-menu-item {
padding-left: 2em;
}

.ui-menu .ui-icon {
position: absolute;
top: 0;
bottom: 0;
left: .2em;
margin: auto 0;
}

.ui-menu .ui-menu-icon {
left: auto;
right: 0;
}

/*
|--------------------------------------------------------------------------
| $CLEARFIX
|--------------------------------------------------------------------------
*/
/**
* Contain floats within an element
*
* @link http://nicolasgallagher.com/micro-clearfix-hack/
*
* 1. The space content is one way to avoid an Opera bug when the
*    contenteditable attribute is included anywhere else in the document.
*    Otherwise it causes space to appear at the top and bottom of elements
*    that are clearfixed.
* 2. The use of 'table' rather than 'block' is only necessary if using
*    ':before' to contain the top-margins of child elements.
*/
.clearfix,
.grid,
.last-login {
overflow: hidden;
height: auto;
}
.clearfix:before, .clearfix:after,
.grid:before,
.last-login:before,
.grid:after,
.last-login:after {
content: " ";
/* 1 */
display: table;
/* 2 */
}
.clearfix:after,
.grid:after,
.last-login:after {
clear: both;
}

.no-margin {
margin: 0 !important;
}

.margin {
margin: 0 0 1.5em 0;
}

.pull-right {
float: right;
}

.pull-left {
float: left;
}

.text-center {
text-align: center;
}

.center-block {
margin: 0 auto 1.5em auto;
}

img {
display: block;
max-width: 100%;
}

/*
|--------------------------------------------------------------------------
| $.hidden
|
| Hides an element
|--------------------------------------------------------------------------
*/
.hidden {
display: none;
}

/* -------------------------------------------------------------
* | Hidden
* ----------------------------------------------------------- */
.none {
display: none;
}

/* -------------------------------------------------------------
* | Whole
* ----------------------------------------------------------- */
.one-whole {
width: 100%;
}

/* -------------------------------------------------------------
* | Halves
* ----------------------------------------------------------- */
.one-half, .two-quarters, .three-sixths, .four-eighths, .five-tenths, .six-twelfths {
width: 50%;
}

/* -------------------------------------------------------------
* | Thirds
* ----------------------------------------------------------- */
.one-third, .two-sixths, .four-twelfths {
width: 33.333%;
}

.two-thirds, .four-sixths, .eight-twelfths {
width: 66.666%;
}

/* -------------------------------------------------------------
* | Quarters
* ----------------------------------------------------------- */
.one-quarter, .two-eighths, .three-twelfths {
width: 25%;
}

.three-quarters, .six-eighths, .nine-twelfths {
width: 75%;
}

/* -------------------------------------------------------------
* | Fifths
* ----------------------------------------------------------- */
.one-fifth, .two-tenths {
width: 20%;
}

.two-fifths, .four-tenths {
width: 40%;
}

.three-fifths, .six-tenths {
width: 60%;
}

.four-fifths, .eight-tenths {
width: 80%;
}

/* -------------------------------------------------------------
* | Sixths
* ----------------------------------------------------------- */
.one-sixth, .two-twelfths {
width: 16.666%;
}

.five-sixths, .ten-twelfths {
width: 83.333%;
}

/* -------------------------------------------------------------
* | Eighths
* ----------------------------------------------------------- */
.one-eighth {
width: 12.5%;
}

.three-eighths {
width: 37.5%;
}

.five-eighths {
width: 62.5%;
}

.seven-eighths {
width: 87.5%;
}

/* -------------------------------------------------------------
* | Tenths
* ----------------------------------------------------------- */
.one-tenth {
width: 10%;
}

.three-tenths {
width: 30%;
}

.seven-tenths {
width: 70%;
}

.nine-tenths {
width: 90%;
}

/* -------------------------------------------------------------
* | Twelfths
* ----------------------------------------------------------- */
.one-twelfth {
width: 8.333%;
}

.five-twelfths {
width: 41.666%;
}

.seven-twelfths {
width: 58.333%;
}

.eleven-twelfths {
width: 91.666%;
}

@media screen and (min-width: 480px) {
/* -------------------------------------------------------------
* | Hidden
* ----------------------------------------------------------- */
.phoneland-none {
display: none;
}

/* -------------------------------------------------------------
* | Whole
* ----------------------------------------------------------- */
.phoneland-one-whole {
width: 100%;
}

/* -------------------------------------------------------------
* | Halves
* ----------------------------------------------------------- */
.phoneland-one-half, .phoneland-two-quarters, .phoneland-three-sixths, .phoneland-four-eighths, .phoneland-five-tenths, .phoneland-six-twelfths {
width: 50%;
}

/* -------------------------------------------------------------
* | Thirds
* ----------------------------------------------------------- */
.phoneland-one-third, .phoneland-two-sixths, .phoneland-four-twelfths {
width: 33.333%;
}

.phoneland-two-thirds, .phoneland-four-sixths, .phoneland-eight-twelfths {
width: 66.666%;
}

/* -------------------------------------------------------------
* | Quarters
* ----------------------------------------------------------- */
.phoneland-one-quarter, .phoneland-two-eighths, .phoneland-three-twelfths {
width: 25%;
}

.phoneland-three-quarters, .phoneland-six-eighths, .phoneland-nine-twelfths {
width: 75%;
}

/* -------------------------------------------------------------
* | Fifths
* ----------------------------------------------------------- */
.phoneland-one-fifth, .phoneland-two-tenths {
width: 20%;
}

.phoneland-two-fifths, .phoneland-four-tenths {
width: 40%;
}

.phoneland-three-fifths, .phoneland-six-tenths {
width: 60%;
}

.phoneland-four-fifths, .phoneland-eight-tenths {
width: 80%;
}

/* -------------------------------------------------------------
* | Sixths
* ----------------------------------------------------------- */
.phoneland-one-sixth, .phoneland-two-twelfths {
width: 16.666%;
}

.phoneland-five-sixths, .phoneland-ten-twelfths {
width: 83.333%;
}

/* -------------------------------------------------------------
* | Eighths
* ----------------------------------------------------------- */
.phoneland-one-eighth {
width: 12.5%;
}

.phoneland-three-eighths {
width: 37.5%;
}

.phoneland-five-eighths {
width: 62.5%;
}

.phoneland-seven-eighths {
width: 87.5%;
}

/* -------------------------------------------------------------
* | Tenths
* ----------------------------------------------------------- */
.phoneland-one-tenth {
width: 10%;
}

.phoneland-three-tenths {
width: 30%;
}

.phoneland-seven-tenths {
width: 70%;
}

.phoneland-nine-tenths {
width: 90%;
}

/* -------------------------------------------------------------
* | Twelfths
* ----------------------------------------------------------- */
.phoneland-one-twelfth {
width: 8.333%;
}

.phoneland-five-twelfths {
width: 41.666%;
}

.phoneland-seven-twelfths {
width: 58.333%;
}

.phoneland-eleven-twelfths {
width: 91.666%;
}
}
@media screen and (min-width: 750px) {
/* -------------------------------------------------------------
* | Hidden
* ----------------------------------------------------------- */
.smalltab-none {
display: none;
}

/* -------------------------------------------------------------
* | Whole
* ----------------------------------------------------------- */
.smalltab-one-whole {
width: 100%;
}

/* -------------------------------------------------------------
* | Halves
* ----------------------------------------------------------- */
.smalltab-one-half, .smalltab-two-quarters, .smalltab-three-sixths, .smalltab-four-eighths, .smalltab-five-tenths, .smalltab-six-twelfths {
width: 50%;
}

/* -------------------------------------------------------------
* | Thirds
* ----------------------------------------------------------- */
.smalltab-one-third, .smalltab-two-sixths, .smalltab-four-twelfths {
width: 33.333%;
}

.smalltab-two-thirds, .smalltab-four-sixths, .smalltab-eight-twelfths {
width: 66.666%;
}

/* -------------------------------------------------------------
* | Quarters
* ----------------------------------------------------------- */
.smalltab-one-quarter, .smalltab-two-eighths, .smalltab-three-twelfths {
width: 25%;
}

.smalltab-three-quarters, .smalltab-six-eighths, .smalltab-nine-twelfths {
width: 75%;
}

/* -------------------------------------------------------------
* | Fifths
* ----------------------------------------------------------- */
.smalltab-one-fifth, .smalltab-two-tenths {
width: 20%;
}

.smalltab-two-fifths, .smalltab-four-tenths {
width: 40%;
}

.smalltab-three-fifths, .smalltab-six-tenths {
width: 60%;
}

.smalltab-four-fifths, .smalltab-eight-tenths {
width: 80%;
}

/* -------------------------------------------------------------
* | Sixths
* ----------------------------------------------------------- */
.smalltab-one-sixth, .smalltab-two-twelfths {
width: 16.666%;
}

.smalltab-five-sixths, .smalltab-ten-twelfths {
width: 83.333%;
}

/* -------------------------------------------------------------
* | Eighths
* ----------------------------------------------------------- */
.smalltab-one-eighth {
width: 12.5%;
}

.smalltab-three-eighths {
width: 37.5%;
}

.smalltab-five-eighths {
width: 62.5%;
}

.smalltab-seven-eighths {
width: 87.5%;
}

/* -------------------------------------------------------------
* | Tenths
* ----------------------------------------------------------- */
.smalltab-one-tenth {
width: 10%;
}

.smalltab-three-tenths {
width: 30%;
}

.smalltab-seven-tenths {
width: 70%;
}

.smalltab-nine-tenths {
width: 90%;
}

/* -------------------------------------------------------------
* | Twelfths
* ----------------------------------------------------------- */
.smalltab-one-twelfth {
width: 8.333%;
}

.smalltab-five-twelfths {
width: 41.666%;
}

.smalltab-seven-twelfths {
width: 58.333%;
}

.smalltab-eleven-twelfths {
width: 91.666%;
}
}
@media screen and (min-width: 768px) {
/* -------------------------------------------------------------
* | Hidden
* ----------------------------------------------------------- */
.tablet-none {
display: none;
}

/* -------------------------------------------------------------
* | Whole
* ----------------------------------------------------------- */
.tablet-one-whole {
width: 100%;
}

/* -------------------------------------------------------------
* | Halves
* ----------------------------------------------------------- */
.tablet-one-half, .tablet-two-quarters, .tablet-three-sixths, .tablet-four-eighths, .tablet-five-tenths, .tablet-six-twelfths {
width: 50%;
}

/* -------------------------------------------------------------
* | Thirds
* ----------------------------------------------------------- */
.tablet-one-third, .tablet-two-sixths, .tablet-four-twelfths {
width: 33.333%;
}

.tablet-two-thirds, .tablet-four-sixths, .tablet-eight-twelfths {
width: 66.666%;
}

/* -------------------------------------------------------------
* | Quarters
* ----------------------------------------------------------- */
.tablet-one-quarter, .tablet-two-eighths, .tablet-three-twelfths {
width: 25%;
}

.tablet-three-quarters, .tablet-six-eighths, .tablet-nine-twelfths {
width: 75%;
}

/* -------------------------------------------------------------
* | Fifths
* ----------------------------------------------------------- */
.tablet-one-fifth, .tablet-two-tenths {
width: 20%;
}

.tablet-two-fifths, .tablet-four-tenths {
width: 40%;
}

.tablet-three-fifths, .tablet-six-tenths {
width: 60%;
}

.tablet-four-fifths, .tablet-eight-tenths {
width: 80%;
}

/* -------------------------------------------------------------
* | Sixths
* ----------------------------------------------------------- */
.tablet-one-sixth, .tablet-two-twelfths {
width: 16.666%;
}

.tablet-five-sixths, .tablet-ten-twelfths {
width: 83.333%;
}

/* -------------------------------------------------------------
* | Eighths
* ----------------------------------------------------------- */
.tablet-one-eighth {
width: 12.5%;
}

.tablet-three-eighths {
width: 37.5%;
}

.tablet-five-eighths {
width: 62.5%;
}

.tablet-seven-eighths {
width: 87.5%;
}

/* -------------------------------------------------------------
* | Tenths
* ----------------------------------------------------------- */
.tablet-one-tenth {
width: 10%;
}

.tablet-three-tenths {
width: 30%;
}

.tablet-seven-tenths {
width: 70%;
}

.tablet-nine-tenths {
width: 90%;
}

/* -------------------------------------------------------------
* | Twelfths
* ----------------------------------------------------------- */
.tablet-one-twelfth {
width: 8.333%;
}

.tablet-five-twelfths {
width: 41.666%;
}

.tablet-seven-twelfths {
width: 58.333%;
}

.tablet-eleven-twelfths {
width: 91.666%;
}
}
@media screen and (min-width: 860px) {
/* -------------------------------------------------------------
* | Hidden
* ----------------------------------------------------------- */
.desktop-none {
display: none;
}

/* -------------------------------------------------------------
* | Whole
* ----------------------------------------------------------- */
.desktop-one-whole {
width: 100%;
}

/* -------------------------------------------------------------
* | Halves
* ----------------------------------------------------------- */
.desktop-one-half, .desktop-two-quarters, .desktop-three-sixths, .desktop-four-eighths, .desktop-five-tenths, .desktop-six-twelfths {
width: 50%;
}

/* -------------------------------------------------------------
* | Thirds
* ----------------------------------------------------------- */
.desktop-one-third, .desktop-two-sixths, .desktop-four-twelfths {
width: 33.333%;
}

.desktop-two-thirds, .desktop-four-sixths, .desktop-eight-twelfths {
width: 66.666%;
}

/* -------------------------------------------------------------
* | Quarters
* ----------------------------------------------------------- */
.desktop-one-quarter, .desktop-two-eighths, .desktop-three-twelfths {
width: 25%;
}

.desktop-three-quarters, .desktop-six-eighths, .desktop-nine-twelfths {
width: 75%;
}

/* -------------------------------------------------------------
* | Fifths
* ----------------------------------------------------------- */
.desktop-one-fifth, .desktop-two-tenths {
width: 20%;
}

.desktop-two-fifths, .desktop-four-tenths {
width: 40%;
}

.desktop-three-fifths, .desktop-six-tenths {
width: 60%;
}

.desktop-four-fifths, .desktop-eight-tenths {
width: 80%;
}

/* -------------------------------------------------------------
* | Sixths
* ----------------------------------------------------------- */
.desktop-one-sixth, .desktop-two-twelfths {
width: 16.666%;
}

.desktop-five-sixths, .desktop-ten-twelfths {
width: 83.333%;
}

/* -------------------------------------------------------------
* | Eighths
* ----------------------------------------------------------- */
.desktop-one-eighth {
width: 12.5%;
}

.desktop-three-eighths {
width: 37.5%;
}

.desktop-five-eighths {
width: 62.5%;
}

.desktop-seven-eighths {
width: 87.5%;
}

/* -------------------------------------------------------------
* | Tenths
* ----------------------------------------------------------- */
.desktop-one-tenth {
width: 10%;
}

.desktop-three-tenths {
width: 30%;
}

.desktop-seven-tenths {
width: 70%;
}

.desktop-nine-tenths {
width: 90%;
}

/* -------------------------------------------------------------
* | Twelfths
* ----------------------------------------------------------- */
.desktop-one-twelfth {
width: 8.333%;
}

.desktop-five-twelfths {
width: 41.666%;
}

.desktop-seven-twelfths {
width: 58.333%;
}

.desktop-eleven-twelfths {
width: 91.666%;
}
}
.grid {
margin: 0px -10px;
}

.grid__unit {
float: left;
padding: 0 10px;
box-sizing: border-box;
}

.pull-right {
float: right;
}

section.grid.state-form.p-confirm-index-ff {
margin: 0;
}

/* Hides the spinner on number inputs */
input[type="number"] {
-moz-appearance: textfield;
}

input::-webkit-outer-spin-button,
input::-webkit-inner-spin-button {
-webkit-appearance: none;
}

html {
font-size: 1em;
}

a {
color: #999999;
}

body {
background: #FFFFFF;
color: #A2A6A9;
font-size: 1em;
}

header {
/* Need .grid for specicifity */
border-bottom: #979797 1px solid;
padding: 15px 20px;
box-sizing: border-box;
}
header .title {
font-weight: bold;
}

li {
margin-top: 4px;
margin-bottom: 4px;
}

body > nav {
border-bottom: #979797 1px solid;
overflow: hidden;
}
body > nav div {
margin: 3px auto;
overflow: hidden;
}
body > nav ul {
margin: 0;
padding: 3px 0px 3px 0px;
display: none;
}
body > nav ul li {
list-style-type: none;
padding: 15px 30px;
border-bottom: 1px solid #E9E9E9;
}
body > nav ul li span {
display: none;
}
body > nav ul li > a {
padding: 10px 0;
display: block;
}
body > nav ul li a:hover {
text-decoration: underline;
}
body > nav ul li div {
display: block;
}
body > nav .menu #current {
float: left;
padding: 20px 30px;
display: block;
}
body > nav .menu #pull {
float: right;
padding: 20px 30px;
display: block;
}

.img-placeholder {
max-width: 100%;
}

#page-stage {
padding: 20px 20px;
}
#page-stage h2 {
margin: 15px 0;
font-size: 1.3em;
line-height: 1.3em;
letter-spacing: -0.5px;
}
#page-stage p {
/*font-size: */
margin: 1em 0;
line-height: 1.5em;
}

footer {
background: #FFFFFF;
border-top: #979797 1px solid;
padding: 15px 20px;
text-align: center;
}
footer ul {
margin: 0;
padding: 0;
}
footer ul li {
list-style-type: none;
margin: 20px 0;
padding: 0;
}

html[lang="en-GB"] footer nav li[data-lang="en-GB"],
html[lang="cy"] footer nav li[data-lang="cy"] {
display: none;
}

.js-mobile {
display: none;
}

html[js-mobile="true"] .js-mobile {
display: block;
}
html[js-mobile="true"] .js-nonmobile {
display: none;
}

.warning {
color: #bb0000;
}

#page-stage .backbtn-warning, #page-stage .summary-warning {
background: #c00;
padding: 1em;
}
#page-stage .backbtn-warning h2, #page-stage .backbtn-warning h3, #page-stage .backbtn-warning p, #page-stage .summary-warning h2, #page-stage .summary-warning h3, #page-stage .summary-warning p {
color: #fff;
}
#page-stage .backbtn-warning h2:first-child, #page-stage .backbtn-warning h3:first-child, #page-stage .backbtn-warning p:first-child, #page-stage .summary-warning h2:first-child, #page-stage .summary-warning h3:first-child, #page-stage .summary-warning p:first-child {
margin-top: 0;
}
#page-stage .backbtn-warning h2:last-child, #page-stage .backbtn-warning h3:last-child, #page-stage .backbtn-warning p:last-child, #page-stage .summary-warning h2:last-child, #page-stage .summary-warning h3:last-child, #page-stage .summary-warning p:last-child {
margin-bottom: 0;
}

.summary-warning {
margin-left: -32px;
margin-right: -32px;
margin-top: -16px;
}

/* Sticky banner */
.banner {
border-bottom: #979797 1px solid;
padding: 15px 20px;
box-sizing: border-box;
background: #F1F1F3;
display: none;
position: relative;
z-index: 1;
}

.banner.sticky {
position: fixed;
left: 0;
top: 0;
width: 100%;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
}

html.has-banner .banner {
display: block;
}

.banner > a[rel="dismiss"] {
position: absolute;
right: 0;
top: 0;
background: transparent;
display: block;
font-size: 1em;
padding: 0.5em 1em;
}

.progress-spinner {
width: 54px;
height: 55px;
background: url(../images/progress-spinner.gif) no-repeat left top;
margin: 1em 0;
}

div.promote {
background: #f0f0f0;
padding: 1px 20px;
}

#wait {
display: none;
position: fixed;
top: 0;
left: 0;
height: 100%;
width: 100%;
background: transparent;
text-align: center;
}
#wait div {
width: 30%;
min-width: 300px;
min-height: 96px;
margin: 25% auto 0 auto;
background: #fff url(../images/progress-spinner.gif) no-repeat 16px center;
border-radius: 8px;
box-shadow: 0 0 10px #000;
box-sizing: border-box;
padding: 2em 2em 2em 80px;
}

html.ui-wait #wait {
display: block;
}

a.btn {
display: inline-block;
padding: 10px 30px;
border-radius: 3px;
border: 1px solid;
margin: 10px 0;
text-align: center;
}
a.btn.max {
padding: 10px 0;
width: 100%;
}

table {
background-color: #FFFFFF;
}

caption {
padding-top: 10px;
padding-bottom: 10px;
text-align: left;
}

th {
text-align: left;
color: #000000;
}

.table {
width: 100%;
max-width: 100%;
margin-bottom: 1.5em;
}
.table > thead > tr > th,
.table > thead > tr > td,
.table > tbody > tr > th,
.table > tbody > tr > td,
.table > tfoot > tr > th,
.table > tfoot > tr > td {
padding: 10px;
line-height: 1.5em;
vertical-align: top;
border-top: 1px solid #F0F0F0;
}
.table > thead > tr > th {
vertical-align: bottom;
border-bottom: 2px solid #F0F0F0;
}
.table > caption + thead > tr:first-child > th,
.table > caption + thead > tr:first-child > td,
.table > colgroup + thead > tr:first-child > th,
.table > colgroup + thead > tr:first-child > td,
.table > thead:first-child > tr:first-child > th,
.table > thead:first-child > tr:first-child > td {
border-top: 0;
}
.table > tbody + tbody {
border-top: 2px solid #F0F0F0;
}
.table .table {
background-color: #FFFFFF;
}

.table-condensed > thead > tr > th,
.table-condensed > thead > tr > td,
.table-condensed > tbody > tr > th,
.table-condensed > tbody > tr > td,
.table-condensed > tfoot > tr > th,
.table-condensed > tfoot > tr > td {
padding: 5px;
}

.table-bordered {
border: 1px solid #F0F0F0;
}
.table-bordered > thead > tr > th,
.table-bordered > thead > tr > td,
.table-bordered > tbody > tr > th,
.table-bordered > tbody > tr > td,
.table-bordered > tfoot > tr > th,
.table-bordered > tfoot > tr > td {
border: 1px solid #F0F0F0;
}
.table-bordered > thead > tr > th,
.table-bordered > thead > tr > td {
border-bottom-width: 2px;
}

.table-striped > tbody > tr:nth-of-type(even) {
background-color: #F2F2F2;
}

.table-hover > tbody > tr:hover {
background-color: #d8d8d8;
}

table col[class*="col-"] {
position: static;
float: none;
display: table-column;
}

table td[class*="col-"],
table th[class*="col-"] {
position: static;
float: none;
display: table-cell;
}

.password-crit {
color: red;
}

.password-crit.crit-valid {
color: green;
}

/* ---------------------------------------------------------- Mobile styling  */
@media screen and (min-width: 480px) {
body > nav > * {
padding: 0;
}
}
/* ---------------------------------------------------------- Tablet styling  */
@media screen and (min-width: 768px) {
body > nav > *,
body > nav ul li .selected {
padding: 0 10px;
}
body > nav ul {
display: block;
}
body > nav ul li {
float: left;
padding: 0;
}
body > nav ul li span {
display: inline-block;
}
body > nav ul li > a {
padding: 20px 20px;
text-align: inherit;
width: inherit;
display: inline-block;
}
body > nav ul li > div {
display: none;
}
body > nav ul li .selected {
display: block;
position: absolute;
left: 0;
right: 0;
padding: 0 10px;
background: #fff;
}
body > nav ul li .selected ul {
max-width: 550px;
margin: 0 auto;
float: none;
}
body > nav .navbar-left {
float: left;
}
body > nav .navbar-right {
float: right;
}
body > nav .menu {
display: none;
}

.modalDialog {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
background: rgba(0, 0, 0, 0.8);
z-index: 99999;
-webkit-transition: opacity 400ms ease-in;
-moz-transition: opacity 400ms ease-in;
transition: opacity 400ms ease-in;
}

.modalDialog:target {
opacity: 1;
pointer-events: auto;
}

.modalDialog > div {
width: 400px;
position: relative;
margin: 10% auto;
padding: 5px 20px 13px 20px;
border-radius: 10px;
background: #FFFFFF;
}
}
/* ---------------------------------------------------------- Desktop styling */
@media screen and (min-width: 860px) {
div.cookie-widget {
margin: 0 auto;
max-width: 550px;
}

header {
border: #979797 1px solid;
padding: 20px 120px;
background-image: none;
}
header > div.container {
max-width: 860px;
}

body > nav > *,
body > nav .selected ul {
padding: 0 110px;
}
body > nav .selected {
padding: 0 !important;
}
body > nav > div.navbar {
max-width: 860px;
}

#page-stage {
padding: 40px 120px;
max-width: 860px;
}

article {
max-width: 550px;
}

footer {
padding: 15px 120px;
}
footer > div.grid {
max-width: 860px;
text-align: left;
}
footer nav {
text-align: right;
}
footer nav li {
display: inline-block;
margin: 20px 5px;
}

.banner {
padding: 15px 120px;
}
}
@media (min-width: 320px) {
.modalDialog {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
background: rgba(0, 0, 0, 0.8);
z-index: 99999;
-webkit-transition: opacity 400ms ease-in;
-moz-transition: opacity 400ms ease-in;
transition: opacity 400ms ease-in;
}

.modalDialog:target {
opacity: 1;
pointer-events: auto;
}

.modalDialog > div {
width: 90%;
text-align: center;
position: relative;
margin: 10% auto;
padding: 5px 20px 13px 20px;
background: #FFFFFF;
}

#modal_img {
margin: 0 auto;
}

#modal_message {
float: left;
}
}
@media (min-width: 480px) {
/* smartphones, Android phones, landscape iPhone */
}
@media (min-width: 600px) {
.modalDialog {
position: fixed;
top: 0;
right: 0;
bottom: 0;
left: 0;
background: rgba(0, 0, 0, 0.8);
z-index: 99999;
-webkit-transition: opacity 400ms ease-in;
-moz-transition: opacity 400ms ease-in;
transition: opacity 400ms ease-in;
}

.modalDialog:target {
opacity: 1;
pointer-events: auto;
}

.modalDialog > div {
width: 400px;
position: relative;
margin: 10% auto;
padding: 5px 20px 13px 20px;
border-radius: 10px;
background: #FFFFFF;
}

#modal_img {
float: left;
}

#modal_message {
float: right;
}
}
@media (max-width: 801px) {
.input .date-group select {
padding: 8px !important;
padding-right: 0px !important;
width: auto !important;
max-width: 75px !important;
min-width: 0px !important;
}

.drivlic-num {
margin-left: 0px !important;
float: left;
}

.drivlice-num1 {
width: 0px !important;
min-width: 56px !important;
}

.drivlice-num2 {
width: 0px !important;
min-width: 60px !important;
}

.drivlice-num3 {
width: 0px !important;
min-width: 35px !important;
}

.drivlice-num4 {
width: 0px !important;
min-width: 33px !important;
}

.drivlice-num5 {
width: 0px !important;
min-width: 33px !important;
}

.input input[type="text"]:not(.year-input) {
padding: 0px !important;
}

button.next-question {
font-size: 11px !important;
padding: 10px 10px !important;
}
}
@media (min-width: 1025px) {
/* big landscape tablets, laptops, and desktops */
}
@media (min-width: 1281px) {
/* hi-res laptops and desktops */
}
fieldset {
border: none;
padding: 0;
margin: 0;
}

#page-stage .field {
padding: 0;
margin: 0;
margin: 20px 0;
}
#page-stage .field .label {
padding: 0;
font-weight: bold;
margin: 0;
}
#page-stage .field .label span.optional {
text-align: right;
display: inline-block;
float: right;
font-weight: normal;
}
#page-stage .field legend.label {
width: 100%;
}
#page-stage .field .tip {
font-weight: normal;
font-size: 0.9em;
margin: 3px 0 5px 0;
}
#page-stage .field .input {
padding: 0;
margin: 0.6em 0;
}
#page-stage .field .input a.skip_submission {
display: inline-block;
float: right;
padding: 12px 0;
}
#page-stage .field.btn-submit {
margin-top: 30px;
}
#page-stage .field.btn-submit .input {
text-align: left;
}

label.error,
p.error {
color: #bb0000;
padding: 2px;
margin: 0.4em 0;
font-size: 0.8em;
display: block;
box-sizing: border-box;
border: 1px solid #bb0000;
}
label.error.reset,
p.error.reset {
opacity: 0;
}
label.error.reset-show,
p.error.reset-show {
opacity: 1;
transition: opacity 0.5s;
}

.input input[type="text"]:not(.year-input), .input input[type="password"], .input input[type="email"], .input input[type="tel"], .input select {
width: 100%;
box-sizing: border-box;
padding: 0.8em;
border: #BCBDBF 1px solid;
border-radius: 3px;
}
.input input[type="text"]:not(.year-input).error, .input input[type="password"].error, .input input[type="email"].error, .input input[type="tel"].error, .input select.error {
border-color: #bb0000;
}
.input input[type="text"]:not(.year-input).error:focus, .input input[type="password"].error:focus, .input input[type="email"].error:focus, .input input[type="tel"].error:focus, .input select.error:focus {
outline-color: #bb0000;
}
.input input[type="number"]::-webkit-outer-spin-button,
.input input[type="number"]::-webkit-inner-spin-button {
-webkit-appearance: none;
margin: 0;
}
.input input:disabled, .input select:disabled {
color: #CCCC;
border-color: #CCCC;
background-color: #EBEBE4;
outline-color: #CCC;
}
.input a.password-toggle {
position: absolute;
right: 1px;
top: 1px;
background: transparent;
font-size: 1em;
line-height: 1em;
padding: 0 6px 0 1em;
}

button {
padding: 12px 24px;
background: #F1F1F3;
border: #BCBDBF 1px solid;
border-radius: 3px;
font-weight: bold;
}
button:disabled, button .disabled, button:disabled:hover, button .disabled:hover {
background: #E0E0E0;
}

form.validating .remote-validation {
background: #f6f6f6;
}

.right-col {
border-top: #979797 1px solid;
margin-top: 30px;
padding-top: 30px;
}

.input .date-group select {
padding: 7px;
width: auto;
min-width: 115px;
/* Effort to correct FF42's calaulation which results in a decimal value */
}
.input .date-group input[type="number"] {
padding: 7px;
width: 56px;
box-sizing: border-box;
}

.radio-group label {
display: block;
margin: 15px 0;
}

input:focus, select:focus, textarea:focus, button:focus, a:focus {
outline: none;
box-shadow: 0 0 4px 2px #0000ff;
}

/* --------------------------------------------------------------- Toggle box */
.toggle-box > .expanded {
display: none;
}

.toggle-box.expanded > .collapsed {
display: none;
}

.toggle-box.expanded > .expanded {
display: block;
padding-left: 3px;
}

.toggle-box button.toggle {
background: transparent;
display: block;
margin: 1em 0;
padding: 0;
text-align: left;
color: #A2A6A9;
font-weight: normal;
}

/* ---------------------------------------------------------- Desktop styling */
@media screen and (min-width: 860px) {
.field.btn-submit .input {
/*text-align: right;*/
}

.right-col {
border-top: none;
margin-top: 0;
padding-top: 0;
}
}
.social-logins li {
list-style-type: none;
margin: 20px 0;
}
.social-logins li a {
display: inline-block;
padding: 12px 12px 12px 70px;
background: #F1F1F3;
background-repeat: no-repeat;
background-position: 20px center;
border-radius: 3px;
border: #BCBDBF 1px solid;
width: 100%;
box-sizing: border-box;
text-decoration: none;
}
.social-logins li a[data-type="facebook"] {
background-image: url(../images/reg/social-fb.png);
}
.social-logins li a[data-type="twitter"] {
background-image: url(../images/reg/social-tw.png);
}
.social-logins li a[data-type="linkedin"] {
background-image: url(../images/reg/social-li.png);
}
.social-logins li a[data-type="google"] {
background-image: url(../images/reg/social-gg.png);
}

.c-address-lookup > div {
display: none;
}
.c-address-lookup > div.search.search-init-keyup button[rel="postcode-lookup-btn"] {
display: none;
}
.c-address-lookup > div.search.search-init-button button[rel="postcode-lookup-btn"] {
display: inline-block;
width: 35%;
}
.c-address-lookup > div.search.search-init-button input[name="postcode_lookup"] {
width: 60%;
}

.c-address-lookup.do-search .search {
display: block;
}

.c-address-lookup.do-entry .fields {
display: block;
}

/* Match code lookup widget */
.matchcode-results-container {
background: #fff;
margin: 0;
border: #ccc 1px solid;
}
.matchcode-results-container > a {
display: block;
border-bottom: #ccc 1px solid;
background: #f9f9f9;
padding: 1em;
box-sizing: border-box;
}
.matchcode-results-container > a:hover {
background: #f0f0f0;
}
.matchcode-results-container ul {
height: 250px;
overflow-x: hidden;
overflow-y: scroll;
list-style-type: none;
}
.matchcode-results-container ul li {
white-space: nowrap;
cursor: pointer;
padding-left: 0.8em;
padding-right: 0.8em;
}
.matchcode-results-container ul li:hover, .matchcode-results-container ul li.cursor-highlghted {
background: #F0F0F0;
}

.matchcode-lookup-input.busy {
background-image: url(../images/spinner.gif);
background-repeat: no-repeat;
background-position: right center;
}

.eu-cookie-notification {
display: none;
padding: 20px;
/* ---------------------------------------------------------- Desktop styling */
}
@media screen and (min-width: 860px) {
.eu-cookie-notification {
padding: 20px 0;
}
}

.page {
background-color: #F3F3F3;
padding: 16px 32px;
margin-bottom: 40px;
max-width: 530px;
margin-left: auto;
margin-right: auto;
}
.page.view-state-hidden {
background-color: transparent;
padding: 0px;
margin: 0px;
}
.page > section {
display: none;
}
.page > section h2 a[rel*="edit-page"], .page > section h2 a.skip_submission, .page > section h3 a[rel*="edit-page"], .page > section h3 a.skip_submission {
display: block;
font-size: 0.7em;
font-weight: normal;
cursor: pointer;
text-decoration: underline;
float: none;
}
.page > section ol.std, .page > section ul.std {
margin: 0 0 0 1.5em;
padding: 0px;
}
.page > section ol.std li, .page > section ul.std li {
margin: 0.5em 0;
padding: 0;
}
.page > section ol.summary, .page > section ul.summary {
margin: 0px 0;
padding: 1px;
}
.page > section ol.summary li, .page > section ul.summary li {
list-style-type: none;
margin: 10px 0px;
padding: 0;
}
.page.view-state-form > section.state-form {
display: block;
}
.page.view-state-summary > section.state-summary {
display: block;
}

div.one-whole > article {
max-width: 600px;
margin-left: auto;
margin-right: auto;
}

.tcs {
margin: 3px;
}

.check-warning-container {
width: 100%;
padding-top: 1px;
}
.check-warning-container > .check-warning {
max-width: 600px;
text-align: left;
margin-top: 20px;
margin-bottom: -20px;
margin-left: auto;
margin-right: auto;
text-align: left;
}
.check-warning-container > .check-warning h2, .check-warning-container > .check-warning h3 {
margin-top: 0;
margin-bottom: 0;
}

.logo-container {
display: flex;
flex-direction: row;
flex-wrap: nowrap;
justify-content: space-between;
align-items: center;
margin-left: auto;
margin-right: auto;
max-width: 594px;
}

/* ---------------------------------------------------------- Desktop styling */
@media screen and (min-width: 860px) {
.page > section h2 {
max-width: 530px;
}
}
.intro-image {
width: 200px;
height: 100px;
background: transparent url("../images/theme/docs/passport.png") no-repeat center center;
background-size: contain;
max-height: 50px;
max-width: 50px;
margin-right: 10px;
}
.intro-image.im-passport {
background-image: url("../images/theme/docs/passport.png");
}
.intro-image.im-driverslicence {
background-image: url("../images/theme/docs/driver.png");
}
.intro-image.im-creditcard {
background-image: url("../images/theme/docs/creditcard.png");
}
.intro-image.im-bank {
background-image: url("../images/theme/docs/bank.png");
}
.intro-image.im-financial {
background-image: url("../images/theme/docs/fin.png");
}

.verify-header {
display: flex;
flex-direction: row;
flex-wrap: nowrap;
justify-content: flex-start;
align-items: center;
}

.p-questions .question a[rel="toggle"] {
font-weight: normal;
}
.p-questions .question .answers label {
display: inline-block;
padding: 1em 0;
}

section.credit-card-details .split-cc input[type="text"] {
width: 4em;
}
section.credit-card-details .split-cc .spacer {
width: 1em;
text-align: center;
display: inline-block;
}
section.credit-card-details .split-cc span {
font-weight: bold;
}
section.credit-card-details #f-credit-card-number-cc {
display: none;
}

.access-codes ul {
margin: 10px 0;
padding: 0;
}
.access-codes ul li {
list-style-type: none;
margin: 10px 0;
padding: 0;
width: 50%;
display: inline-block;
}

.p-index .signin-issues-help {
display: none;
/* Hidden until JS takes over */
font-weight: bold;
color: #0c507a;
}
.p-index .signin-issues-help a {
color: #0c507a;
text-decoration: underline;
}
.p-index .signin-issues-help a:hover {
text-decoration: none;
}

.p-prev-addresses .previous-address {
background: #F3F3F3;
padding: 1px;
}
.p-prev-addresses .previous-address span {
display: block;
margin: 15px;
}
.p-prev-addresses .previous-address span.remove a {
color: #bb0000;
}

.p-confirmation .signin-issues-help {
display: none;
/* Hidden until JS takes over */
font-weight: bold;
color: #0c507a;
}
.p-confirmation .signin-issues-help a {
color: #0c507a;
text-decoration: underline;
}
.p-confirmation .signin-issues-help a:hover {
text-decoration: none;
}

.p-complete .icon-list {
list-style-type: none;
margin: 1em 0;
padding: 0;
}
.p-complete .icon-list li {
margin: 15px 0;
padding: 20px 0 20px 70px;
height: 10px;
line-height: 10px;
background: no-repeat left center;
font-weight: bold;
}
.p-complete .icon-list li.p {
background-image: url(../images/theme/docs/passport.png);
}
.p-complete .icon-list li.d {
background-image: url(../images/theme/docs/fin.png);
}
.p-complete .icon-list li.b {
background-image: url(../images/theme/docs/bank.png);
}
.p-complete .icon-list li.t {
background-image: url(../images/theme/docs/time.png);
}
.p-complete .icon-list li.f {
background-image: url(../images/theme/docs/fin.png);
}
.p-complete .icon-list li.c {
background-image: url(../images/theme/docs/creditcard.png);
}

.p-second-factor .access-codes span {
display: inline-block;
width: 50%;
margin: 10px 0;
box-sizing: border-box;
}
.p-second-factor .instructions li {
margin: 10px 0;
}

.p-signin-index-ff .signin-issues-help {
display: none;
/* Hidden until JS takes over */
font-weight: bold;
color: #0c507a;
}
.p-signin-index-ff .signin-issues-help a {
color: #0c507a;
text-decoration: underline;
}
.p-signin-index-ff .signin-issues-help a:hover {
text-decoration: none;
}

.p-signin-index-sf .option,
.p-confirm-index-ff .option {
display: none;
}

.last-login {
padding: 0 30px;
overflow: hidden;
}
.last-login span {
margin-top: 20px;
float: right;
}

.welcome-message {
clear: both;
margin: 0 auto;
text-align: center;
padding: 20px;
}
.welcome-message h1 {
font-size: 3em;
}

.map-img {
position: absolute;
-webkit-box-shadow: 2px 3px 15px 0px rgba(0, 0, 0, 0.75);
-moz-box-shadow: 2px 3px 15px 0px rgba(0, 0, 0, 0.75);
box-shadow: 2px 3px 15px 0px rgba(0, 0, 0, 0.75);
}

section h2 a,
section h3 a {
float: right;
text-decoration: underline;
}

.p-close-account .option {
display: none;
}

.p-second-factor-acm .mode-attach, .p-second-factor-acm .mode-detach {
display: none;
/* Both modes hidden and enabled at runtime by js logic */
}

/*.p-second-factor-acm {
.access-codes {
span {
display: inline-block;
width: 50%;
margin: 10px 0;
box-sizing: border-box;
}
}

.instructions {
li {
margin: 10px 0;
}
}

hr {
display: block;
height: 1px;
border: 0;
border-top: 1px solid #BCBDBF;
margin: 1em 0;
padding: 0;
}

> article > div {
margin-bottom: 60px;
}

button {
width: 100%;
}

.btn {
@extend .max;
}
}*/
.p-acm-confirm-index-sf .option {
display: none;
}

/* ---------------------------------------------------------- Tablet styling */
@media screen and (min-width: 860px) {
.welcome-message {
padding: 100px 120px;
}

.last-login {
margin: 0 auto;
max-width: 550px;
padding: 0 120px;
}
}
dl dt.head {
font-weight: bold;
}
dl dt, dl dd {
margin-top: 1em;
margin-bottom: 1em;
}

/*@font-face {
font-family: "ChevinPro-DemiBold";
src:    url("../fonts/ChevinPro-DemiBold.eot") format("eot"),
url("../fonts/ChevinPro-DemiBold.woff") format("woff"),
url("../fonts/ChevinPro-DemiBold.ttf") format("truetype");
}

@font-face {
font-family: "ChevinPro-Medium";
src:    url("../fonts/ChevinPro-Medium.eot") format("eot"),
url("../fonts/ChevinPro-Medium.ttf") format("truetype");
}*/
@font-face {
font-family: "ChevinPro-Light";
src: url("../fonts/ChevinPro-Light.eot") format("eot"), url("../fonts/ChevinPro-Light.woff") format("woff"), url("../fonts/ChevinPro-Light.ttf") format("truetype");
}
body {
color: #626667;
font-family: "ChevinPro-Light", Helvetica, Arial, sans-serif;
}

a {
color: #0c507a;
text-decoration: underline;
}

a.btn {
background-color: #CC0000;
color: #FFFFFF;
}
a.btn:hover {
background-color: #990000;
}

header {
background-color: #CC0000;
color: #FFFFFF;
border: 0 none;
}
header .logo-rmg, header .logo-gov {
height: 79px;
}
header .logo-rmg {
width: 173px;
background: url(/public/images/verify/sites/royalmail/head-logo-mobile.png) no-repeat left top;
background-size: contain;
}
header .logo-rmg .title {
visibility: hidden;
}
header .logo-gov {
text-align: right;
}
header .logo-gov a {
width: 173px;
height: 75px;
background: url(/public/images/verify/sites/royalmail/govuk-verify-mobile.png) no-repeat;
background-size: contain;
display: inline-block;
}
header .logo-gov .hidden-text {
position: absolute;
left: -3000px;
top: auto;
width: 1px;
height: 1px;
overflow: hidden;
outline: none;
}

body > nav {
border: 0 none;
background-color: #AE020F;
}
body > nav .menu {
background-color: #AE020F;
}
body > nav .menu a, body > nav .menu span {
color: #FFFFFF;
}
body > nav a, body > nav span {
color: #666666;
}
body > nav ul li {
background-color: #FFF;
}
body > nav ul li > div ul li {
border-bottom: 0 none;
}
body > nav .menu #pull {
padding: 8px 10px;
width: 44px;
height: 44px;
background: url(../../webres/images/theme/toggle-box-btn-expanded-white.png) no-repeat center center;
text-indent: 10000px;
white-space: nowrap;
overflow: hidden;
}
body > nav .menu #pull.expand {
transform: rotate(-180deg);
transition: .3s;
}
body > nav .menu #pull.collapse {
transform: rotate(0deg);
transition: .3s;
}

#page-stage h2 {
color: #333;
font-family: "ChevinPro-Light", Helvetica, Arial, sans-serif;
font-size: 1.5em;
}
#page-stage h3 {
color: #666;
font-family: "ChevinPro-Light", Helvetica, Arial, sans-serif;
font-size: 1.25em;
}
#page-stage .backbtn-warning a, #page-stage .summary-warning a {
color: #fff;
text-decoration: underline;
}
#page-stage .backbtn-warning a:hover, #page-stage .summary-warning a:hover {
text-decoration: none;
}
#page-stage .backbtn-warning {
font-size: 90%;
}

.close-container {
background-color: #fff;
margin-top: -50px;
padding: 10px;
}
.close-container > div.close-account {
text-align: right;
padding-left: 32px;
padding-right: 32px;
}

button {
background-color: #CC0000;
color: #FFFFFF;
border: none;
}
button:hover {
background-color: #97040C;
}
button:focus {
outline-color: #00f;
}

.message {
padding: 20px;
}
#page-stage .message p {
margin: 0;
}

.message, .banner {
background-color: #EDF5FF;
border: 1px solid #CAE0FE;
}

.toggle-box button.toggle {
display: block;
margin: 1em 0;
padding: 0 0 0 16px;
text-align: left;
color: #0c507a;
font-weight: normal;
background-color: transparent;
background-repeat: no-repeat;
background-position: left center;
}
.toggle-box > .collapsed > button.toggle {
background-image: url("../../webres/images/theme/toggle-box-btn-collapsed.png");
}
.toggle-box > .expanded > button.toggle {
background-image: url("../../webres/images/theme/toggle-box-btn-expanded.png");
}

/* ---------------------------------------------------------- Tablet styling  */
@media screen and (min-width: 768px) {
body > nav ul li {
border-bottom: 0 none;
}
body > nav > div > ul > li {
background-color: #AE020F;
}
body > nav > div > ul > li a, body > nav > div > ul > li span {
color: #FFFFFF;
}
body > nav > div > ul > li .selected li a, body > nav > div > ul > li .selected li span {
color: #626667;
}

.close-container {
max-width: 100%;
padding-top: 10px;
padding-bottom: 10px;
margin-top: -70px;
}
.close-container > div.close-account {
max-width: 550px;
margin: auto;
}
}
/* ---------------------------------------------------------- Desktop styling */
@media screen and (min-width: 860px) {
header, #page-stage, footer {
text-align: center;
}

header > div.logo-container > div.rmg-logo {
background: url(../../webres/images/theme/head-logo-desktop.png) no-repeat left top;
}
header > div.logo-container > div.logo-gov a {
background: url(/public/images/verify/sites/royalmail/govuk-verify-desktop.png) no-repeat;
}

#page-stage {
max-width: 100%;
}
#page-stage > article {
text-align: left;
margin-left: auto;
margin-right: auto;
}

footer {
border: none;
}
footer > div.grid {
max-width: 550px;
text-align: left;
margin: 0 auto;
}

.close-container {
max-width: 100%;
padding: 10px 120px;
margin-top: -80px;
}
.close-container > div.close-account {
max-width: 550px;
margin: auto;
}
}
/* ----------------------------------------------------------- Retina imagery */
@media only screen and (min--moz-device-pixel-ratio: 2), only screen and (-o-min-device-pixel-ratio: 2 / 1), only screen and (-webkit-min-device-pixel-ratio: 2), only screen and (min-device-pixel-ratio: 2) {
header > div.logo-container > div.rmg-logo {
background-image: url(../../webres/images/theme/head-logo-mobile-retina.png) no-repeat;
}
header > div.logo-container > div.logo-gov a {
background-image: url(../../webres/images/govuk-verify-mobile-retina.png) no-repeat;
}
}
@media only screen and (min-width: 860px) and (min--moz-device-pixel-ratio: 2), only screen and (min-width: 860px) and (-o-min-device-pixel-ratio: 2 / 1), only screen and (min-width: 860px) and (-webkit-min-device-pixel-ratio: 2), only screen and (min-width: 860px) and (min-device-pixel-ratio: 2) {
header > div.container > div.grid .logo-rmg {
background-image: url(../../webres/images/theme/head-logo-desktop-retina.png) no-repeat;
}

header > div.container > div.grid .logo-gov a {
background-image: url(../../webres/images/govuk-verify-desktop-retina.png) no-repeat;
}
}
#page-stage .welcome-message h1 {
color: #000000;
}

#page-stage .welcome-message h2 {
color: #626667;
}

/*# sourceMappingURL=avoco.css.map */