Square made its name by offering a free card reader for iPhones and low cost (2.75%) credit card transaction fees. But, Square wants to make transactions even simpler and introduced the Card Case to make that happen
How all this actually works appears to be a bit of a mystery. There is an initial setup process that associates your credit with a specific retail outlet (say a cafe). This is supposed to allow you to have purchases on subsequent visits applied to your credit line by simply identifying yourself by name. There is no description on your stated identify is verified by, for example, a worker who does not recognize you.
We know this much: You can browse a menu and open a tab when within 500 feet of your destination. This distance is too large for using Bluetooth or WiFi (under normal conditions). This indicates that Square’s system uses 3G and GPS or cell tower location information. This would account for the 500 distance.


I am heading to Seattle for a conference - entering the country using the Visa Waiver Program. I would like to make a quick trip - probably one day or two at the most - to Vancouver and then come back to Seattle before flying home. Can someone tell me if I may expect to have problems coming back into the USA with my waived visa?
You will have no problems at all.
Officially your 90 day WVP entry into the US will not be reset by the quick visit to Canada, although realistically I'm not sure how this is enforced nowadays. (It used to be that you would keep the I-94W form that you received when you first entered the US, and re-use it to re-enter from Canada, but as I-94W's no longer exist this may not happen).
Regardless of whether they treat it as two entries or one, it's not a problem.
You will also need to confirm that you do not need a Visa to enter Canada. Presuming you're an Australian, you should not need one (presuming no crime record/etc, but if you can get into the US under WVP you should have no issues getting into Canada either).
If you are able to visit the US on a visa waiver then you are probably able to visit Canada without a visa. You should probably check to be on the safe side. Likewise there should be no problem with exiting and re-entering the US on a visa waiver.


Hi there, I'm Thomas! I'm a software developer who loves to code, and I'm currently trying to eat less cake. This is my minimalist blog where I write about the interesting things I'm learning.
Articles from 2019:
Articles from 2018:
- Finding prime numbers with Eratosthenes
- A fascinating method to draw fractals
- Learn to make HTML5 games with Phaser 3
If you have any questions or feedback: email@example.com :-)


Take Your Career to the Next Level by Joining the
Treeful Damaso Aniceto, Inc Team!
Interested in joining the Treeful Damaso Aniceto, Inc team?
We are a group of highly-motivated, passionate professionals who strive to deliver excellent results to our clients. Working at a small firm means your voice will be heard - we are always looking to improve! And for a bunch of accountants, we sure do have fun!


A roll cage is a specially engineered and constructed frame built in (or sometimes around, in which case it is known as an exo cage) the passenger compartment of a vehicle to protect its occupants from being injured in an accident, particularly in the event of a roll-over.
There are many different roll cage designs depending on the application, hence different racing organizations have differing specifications and regulations. They also help to stiffen the chassis, which is desirable in racing applications.
A roll bar is a single bar behind the driver that provides moderate roll-over protection. Due to the lack of a protective top, some modern convertibles utilize a strong windscreen frame acting as a roll bar. Also, a roll hoop may be placed behind both headrests (usually one on older cars), which is essentially a roll bar spanning the width of a passenger's shoulders.
A newer form of rollover protection, pioneered on the Mercedes-Benz R129 in 1989, is deployable roll hoops that are normally hidden within the body of a car. When sensors detect an imminent rollover, the roll hoops quickly extend and lock in place. Cars that have a deployable rollover protection system include the Peugeot 307 CC,Volvo C70, Mercedes-Benz SL 500, and Jaguar XK.
Formally, an (r,g)-graph is defined to be a graph in which each vertex has exactly r neighbors, and in which the shortest cycle has length exactly g. It is known that an (r,g)-graph exists for any combination of r ≥ 2 and g ≥ 3. An (r,g)-cage is an (r,g)-graph with the fewest possible number of vertices, among all (r,g)-graphs.
If a Moore graph exists with degree r and girth g, it must be a cage. Moreover, the bounds on the sizes of Moore graphs generalize to cages: any cage with odd girth g must have at least
vertices, and any cage with even girth g must have at least
vertices. Any (r,g)-graph with exactly this many vertices is by definition a Moore graph and therefore automatically a cage.
A cage is an enclosure made of mesh, bars or wires, used to confine, contain or protect something or someone. A cage can serve many purposes, including keeping an animal in captivity, capturing, and being used for display of an animal at a zoo.
In history, prisoners were sometimes kept in a cage. They would sometimes be chained up inside into uncomfortable positions to intensify suffering.
Cages have been usually been used to capture or trapping a certain life form. For this reason, they've been known as a hunting accessory, often used for poaching animals or simply seizing them.
Cages are often used now as a source to confine animals. These provide as a habitat to the animal, and since they've advanced so greatly, they are now specially designed to fit that species of animal. Captive breeds of birds, rodents, reptiles, and even larger animals have also been known to be confined in a cage as a domesticated animal (also known as a pet). Captivity is a common purpose of the cage.
Luke Cage was created by Archie Goodwin and John Romita, Sr. shortly after Blaxploitation films emerged as a popular new genre. He debuted in his own series, Luke Cage, Hero for Hire, which was initially written by Goodwin and pencilled by George Tuska. Cage's adventures were set in a grungier, more crime-dominated New York City than that inhabited by other Marvel superheroes of the time. The series was retitled Luke Cage, Power Man with issue #17.
Flight dynamics is the study of the performance, stability, and control of vehicles flying through the air or in outer space. It is concerned with how forces acting on the vehicle influence its speed and attitude with respect to time.
In fixed-wing aircraft, the changing orientation of the vehicle with respect to the local air flow is represented by two critical parameters, angle of attack ("alpha") and angle of sideslip ("beta"). These angles describe the vector direction of airspeed, important because it is the principal source of modulations in the aerodynamic forces and moments applied to the aircraft.
Spacecraft flight dynamics involve three forces: propulsive (rocket engine), gravitational, and lift and drag (when traveling through the earths or any other celestial atmosphere). Because aerodynamic forces involved with spacecraft flight are very small, this leaves gravity as the dominant force.
Aircraft and spacecraft share a critical interest in their orientation with respect to the earth horizon and heading, and this is represented by another set of angles, "yaw," "pitch" and "roll" which angles match their colloquial meaning, but also have formal definition as an Euler sequence. These angles are the product of the rotational equations of motion, where orientation responds to torque, just as the velocity of a vehicle responds to forces. For all flight vehicles, these two sets of dynamics, rotational and translational, operate simultaneously and in a coupled fashion to evolve the vehicle's state (orientation and velocity) trajectory.
Euler angles represent a sequence of three elemental rotations, i.e. rotations about the axes of a coordinate system. For instance, a first rotation about z by an angle α, a second rotation about x by an angle β, and a last rotation again about y, by an angle γ. These rotations start from a known standard orientation. In physics, this standard initial orientation is typically represented by a motionless (fixed, global, or world) coordinate system; in linear algebra, by a standard basis.
Any orientation can be achieved by composing three elemental rotations. The elemental rotations can either occur about the axes of the fixed coordinate system (extrinsic rotations) or about the axes of a rotating coordinate system, which is initially aligned with the fixed one, and modifies its orientation after each elemental rotation (intrinsic rotations). The rotating coordinate system may be imagined to be rigidly attached to a rigid body. In this case, it is sometimes called a local coordinate system. Without considering the possibility of using two different conventions for the definition of the rotation axes (intrinsic or extrinsic), there exist twelve possible sequences of rotation axes, divided in two groups:


As a computer science student, Alex faces a hard challenge — showering. He tries to shower daily, but despite his best efforts there are always challenges. He takes $$$s$$$ minutes to shower and a day only has $$$m$$$ minutes!

He already has $$$n$$$ tasks planned for the day. Task $$$i$$$ is represented as an interval $$$(l_i$$$, $$$r_i)$$$, which means that Alex is busy and can not take a shower in that time interval (at any point in time strictly between $$$l_i$$$ and $$$r_i$$$). No two tasks overlap.

Given all $$$n$$$ time intervals, will Alex be able to shower that day? In other words, will Alex have a free time interval of length at least $$$s$$$?

In the first test case, Alex can shower for the first $$$3$$$ minutes of the day and not miss any of the tasks.


- 1 Introduction
- 2 Smaller Change & Implementation
- 3 Mid-level Change & Implementation
- 4 Larger Change & Implementation
In Firefox 3.0, managing content such as bookmarks, tabs, and history is very limited. While the awesome bar came a long way in improving targeted search for a particular item, browse-based interactions for bookmarks, history, and tabs is still missing. The only way to really "browse" this content is either by using the library, which is truly on an OS-based file management system, or by using tabs. Both of these systems do not allow users to preview, search, and navigate content visually. The library system only provides text descriptions and favicons. Similarly, tabbed content only shows a favicon and part of the title, and beyond a handful of tabs the rest are obscured in an overflow dropdown menu. This system makes searching for a particular item and browsing content difficult.
There have been many add-ons and unrelated programs which have experimented with novels ways to browse content. Among these are:
- Spacetime: Visual 3D search for Yahoo! Images and Google Images, displays in visual "stacks"
- Live Lab's Seadragon (ZUI): Introduces navigation based on extreme zooming. Content is laid out and zooming into an area brings you to that content. Zooming in to specific area on a page opens up new content.
- Bumptop: "Realistic" desktop with physics model so items can be tossed, stacked, shuffled around like weighted objects
- PicLens: Firefox extensions which presents sites and images as a 3D wall in space, can sort objects by a search query
- Thumbstrips: Firefox extension which displays previews of open tabs as strip of thumbnails which can be hidden
- Flock's Media Bar: a social networking-focused browser built on the Firefox codebase, where media is browsable by a preview bar at the top of the window
- Pogo: At&t's not-yet-released 3D spacey browser, with files fading off into the background in fish-eyed 3D stacks
- Opera and IE: Pages visible as a grid of thumbnails
While many of these interactions are interesting and novel, they may not be the best features to come standard with Firefox. For instance, PicLens is an interesting way to browse content and many Firefox users have it as an add-on, but creating something this CPU-intensive as part of the browser would not likely serve the needs of many users.
I've been doing some sketches and thinking about what kinds of features related to previewing and searching content may make sense for the next version of Firefox. I've taken the sketches that I feel have the most potential and grouped them into three categories, based on how easy they might be to implement and how big a change they will cause.
Evaluation for 3.1:
- Canvas3d is available
- Problems storing / retrieving image data quickly enough
- Needs immediate consultation with the platform team
- potentially low benefit (don't use coverflow, do use grid view)
- Seems like rich ground, might need a bit more exploration
- Smaller change & implementation (see below) may be appropriate for 3.1, while more major changes may need to wait until 4.0
- Many methods of visual navigation are already available as addons
Smaller Change & Implementation
These are subtle changes to the existing UI that could make navigating content easier and more efficient.
Tab Icons in Awesomebar
Currently, the awesomebar displays an icon to show the user that an awesomebar result is a favorite or a tag, but it gives no indication if an awesomebar result is open in another tab. Showing open tabs here not only is consistent with the current UI, but also helps the problem of accidentally opening duplicates of the same tab. By alerting the user of open tabs, the user can choose to either navigate to that tab or create a new instance of the URL.
Tab List in Sidebar
This isn't so much an idea for a design as much as a move to make the Firefox interface more intuitive. Currently history and bookmarks can be shown in the sidebar, but not tabs.
By grouping tabs by domain in the list, users can more easily get a sense of where their tabs are and what tasks they are in the middle of. An important features of this arrangement would be to close a group of tabs by domain. For example, if someone is finished with their online banking, they can close a group of Bank of America tabs rather than hunt around for the individual tabs and windows.
Thumbnail Previews in Tooltips
This small and relatively low CPU-draining feature would give the user an indication of what item they are nagivating to. This interaction is already used online in several addons to preview where a link will go, prevent rick rolling.
This could be used in the library:
Over a tab:
In the sidebar:
Or in the bookmarks menu:
Mid-level Change & Implementation
Dropdown Domain-Specific Menus from Tabs
A common problem in the current Firefox tab menu is that the user may be performing many different tasks in a single window over many tabs. These tabs are not currently grouped by domain nor tasks, but are layed out linearly in the order they were created. This makes completing a task which requires many tabs difficult and forces the user to hunt for the tabs they need.
In the above example, the user is engaged in multiple tasks in multiple domains, but the interface gives no clear affordance of this.
Being able to group open tabs by domain is one way to address this problem. In this sketch, which came out of a conversation with Jay Sullivan, the user clicks and holds down a tab. This produces a drop-down menu which shows all tabs open for that domain. This interactions mirrors the operating system method of seeing all windows open for a particular application in that application's menu.
Pull-down Thumbnail Grid
This is a for a quick way to preview tabbed content as thumbnails. The user goes to any tab and drags down to see thumbnail previews of the tabs at the top. If the user continues to pull down, he sees thumbnails of previously obscured tabs. If a tab is only partially loaded, this is represented by a semi-transparent loaded bar over the tab.
This addresses the problem of many tabs looking identical by allowing the user to get a quick view of what’s open and what’s loaded.
This is similar to the interaction in Thumbstrips, but a lighter-weight solution that's easy to pull out and in. A point Aza made is that this is not an elegant solution, but possibly more of a halfway fix, since obscuring your view certainly does not allow the user to navigate and preview at the same time.
The user wants to create a spreadsheet based on data from an article. So, he needs his workspace to have both a spreadsheet and an article in view. He clicks the first tab he wants to be open and then the second. He opens them both by double clicking.
Both tabs open next to each other, providing a workspace for the user to utilize both windows. The user can change the window layout to edit his workspace
Ability to View Library Content as Folders and Thumbnails
This system would function very similarly to a current operating system: folders of content would be displayed in a grid as folders and URLs would be given thumbnail previews. Internet Explorer and Opera have similar systems of viewing tabs as thumbnail grids, though they don't so far as to use folders for directories.
Larger Change & Implementation
Separate "Tab Management Window"
As described in the previous wiki, this tab management window would work like a more visual version of the current Library. These sketches are for a separate “tab management” window, where the user can organize and view tabs visually. They can view open tabs as a grid, a list, or in “scatter,” mode. Scatter mode provides the user with a free-form arrangement of tabs (and possibly history) which they can organize spatially. The user can choose to view their tabs in scatter mode:
- By site. This groups tabs together by what domain they were reached through. If the user has ten articles open from the New York Times, these will be grouped together with the New York Times homepage being largest.
- By topic. This groups tabs together by what searches they were accessed through. If the user has performed a Google search on San Francisco restaurants, all tabs resulting from this search are grouped together.
- By recency & frequency. Using the idea behind the Awesomebar, sites which are visited frequently and recently appear larger in tab view and are thus easier and faster to recognize and click.
- In freeform. The user can resize and move tabs, grouping them in whatever way fits with their working model for a project. They can add labels and fields to help create organizational systems and save their tab configurations for future sessions.
Another way to show content not as individual items but as steps in longer navigation tasks is by visually linking them. In these sketches, the navigation the user has taken is represented in a tree structure; whenever the user clicks a link, a branch is drawn from the location they were at to the one they are navigating to. This makes it easy to see the path the user has taken.
An issue with the current tab system is that many tabs can be opened, ignored, and forgotten about over time, silently eating up CPU in the background. With a timed interface, the user can see when they viewed which websites and perhaps delete unused websites accordingly. In the sketch, websites drift towards the left over time, so that new sites appear in the right-most column.


There are n employees in Alternative Cake Manufacturing (ACM). They are now voting on some very important question and the leading world media are trying to predict the outcome of the vote.

Each of the employees belongs to one of two fractions: depublicans or remocrats, and these two fractions have opposite opinions on what should be the outcome of the vote. The voting procedure is rather complicated:

1. Each of n employees makes a statement. They make statements one by one starting from employees 1 and finishing with employee n. If at the moment when it's time for the i-th employee to make a statement he no longer has the right to vote, he just skips his turn (and no longer takes part in this voting).
2. When employee makes a statement, he can do nothing or declare that one of the other employees no longer has a right to vote. It's allowed to deny from voting people who already made the statement or people who are only waiting to do so. If someone is denied from voting he no longer participates in the voting till the very end.
3. When all employees are done with their statements, the procedure repeats: again, each employees starting from 1 and finishing with n who are still eligible to vote make their statements.
4. The process repeats until there is only one employee eligible to vote remaining and he determines the outcome of the whole voting. Of course, he votes for the decision suitable for his fraction.

You know the order employees are going to vote and that they behave optimal (and they also know the order and who belongs to which fraction). Predict the outcome of the vote.


Kate Crossbody Clutch - Click for Colors
Thanks for signing up!
There was an error signing up, please try again.
The New Kate crossbody clutch is made of vegan leather. It’s just the right size for carrying all your essentials. Features three zip compartments, 6 credit card slots and a license pocket. Style it with either the slender wristlet strap or slim crossbody strap.


In the country of Dengkleknesia, there are $$$N$$$ factories numbered from $$$1$$$ to $$$N$$$. Factory $$$i$$$ has an electrical coefficient of $$$A_i$$$. There are also $$$N-1$$$ power lines with the $$$j$$$-th power line connecting factory $$$U_j$$$ and factory $$$V_j$$$. It can be guaranteed that each factory in Dengkleknesia is connected to all other factories in Dengkleknesia through one or more power lines. In other words, the collection of factories forms a tree. Each pair of different factories in Dengkleknesia can use one or more existing power lines to transfer electricity to each other. However, each power line needs to be turned on first so that electricity can pass through it.

Define $$$f(x, y, z)$$$ as the minimum number of power lines that need to be turned on so that factory $$$x$$$ can make electrical transfers to factory $$$y$$$ and factory $$$z$$$. Also define $$$g(x, y, z)$$$ as the number of distinct prime factors of $$$\text{GCD}(A_x, A_y, A_z)$$$.

To measure the electrical efficiency, you must find the sum of $$$f(x, y, z) \times g(x, y, z)$$$ for all combinations of $$$(x, y, z)$$$ such that $$$1 \leq x < y < z \leq N$$$. Because the answer can be very large, you just need to output the answer modulo $$$998\,244\,353$$$.

Note: $$$\text{GCD}(k_1, k_2, k_3)$$$ is the greatest common divisor of $$$k_1$$$, $$$k_2$$$, and $$$k_3$$$, which is the biggest integer that simultaneously divides $$$k_1$$$, $$$k_2$$$, and $$$k_3$$$.


#ifndef VKST_RENDERER_H
#define VKST_RENDERER_H

#include <plat/filesystem.h>
#include <wsi/window.h>
#include <vk/result.h>
#include <gsl.h>
#include <filesystem>
#include <vector>

// Holds all of the data for a surface. This includes the swapchain,
// renderpass, and framebuffers.
// Surfaces must be resized when the window is resized.
class surface {
public:
  std::size_t num_images() const noexcept { return _color_images.size(); }

  VkRenderPass render_pass() const noexcept { return _render_pass; }

  VkFramebuffer framebuffer(std::size_t index) const noexcept {
    return _framebuffers[index];
  }

  VkSampleCountFlagBits samples() const noexcept { return _samples; }

  VkViewport& viewport() noexcept { return _viewport; }
  VkViewport const& viewport() const noexcept { return _viewport; }

  VkRect2D& scissor() noexcept { return _scissor; }
  VkRect2D const& scissor() const noexcept { return _scissor; }

  surface() noexcept {}
  surface(surface const&) = delete;
  surface(surface&& other) noexcept;
  surface& operator=(surface const&) = delete;
  surface& operator=(surface&& rhs) noexcept;
  ~surface() noexcept = default;

private:
  VkSurfaceKHR _surface{VK_NULL_HANDLE};

  VkSurfaceFormatKHR _color_format{};
  VkFormat _depth_format{};
  VkSampleCountFlagBits _samples{};
  VkPresentModeKHR _present_mode{};

  VkSemaphore _image_available{VK_NULL_HANDLE};
  VkSemaphore _render_finished{VK_NULL_HANDLE};
  VkRenderPass _render_pass{VK_NULL_HANDLE};

  VkSurfaceCapabilitiesKHR _capabilities{};
  VkExtent2D _extent{};
  VkViewport _viewport{};
  VkRect2D _scissor{};
  VkSwapchainKHR _swapchain{VK_NULL_HANDLE};

  constexpr static uint32_t MAX_IMAGES = 4;
  std::vector<VkImage> _color_images{};
  std::vector<VkImageView> _color_image_views{};

  VkImage _depth_image{VK_NULL_HANDLE};
  VkDeviceMemory _depth_image_memory{VK_NULL_HANDLE};
  VkImageView _depth_image_view{VK_NULL_HANDLE};

  VkImage _color_target{VK_NULL_HANDLE};
  VkDeviceMemory _color_target_memory{VK_NULL_HANDLE};
  VkImageView _color_target_view{VK_NULL_HANDLE};

  VkImage _depth_target{VK_NULL_HANDLE};
  VkDeviceMemory _depth_target_memory{VK_NULL_HANDLE};
  VkImageView _depth_target_view{VK_NULL_HANDLE};

  std::vector<VkFramebuffer> _framebuffers{};

  friend class renderer;
}; // class surface

// Convenience class to hold both the VkShaderModule for a shader as well as
// any error message from compiling the shader.
class shader {
public:
  enum class types : uint8_t {
    vertex = 0,
    fragment = 1,
  }; // enum class types

  operator VkShaderModule() const noexcept { return _module; }

  std::string const& error_message() const noexcept { return _error_message; }

  shader() noexcept {}
  shader(shader const&) = delete;
  shader(shader&& other) noexcept;
  shader& operator=(shader const&) = delete;
  shader& operator=(shader&& rhs) noexcept;
  ~shader() noexcept = default;

private:
  VkShaderModule _module{VK_NULL_HANDLE};
  std::string _error_message{};

  friend class renderer;
}; // class shader

enum class renderer_result {
  success = 0,
  no_device = 1,
  initialization_failed = 2,
  surface_not_supported = 3,
  no_memory_type = 4,
}; // class renderer_result

class renderer_result_category_impl : public std::error_category {
public:
  virtual char const* name() const noexcept override {
    return "renderer_result";
  }

  virtual std::string message(int ev) const override;
}; // class renderer_result_category_impl

std::error_category const& renderer_result_category();

inline std::error_code make_error_code(renderer_result e) noexcept {
  return {static_cast<int>(e), renderer_result_category()};
}

enum class renderer_options : uint8_t {
  none = 0,
  use_integrated_gpu = (1 << 1),
}; // renderer_options

// Holds all of the data for rendering. Also provides methods for creating
// surfaces, shaders, pipelines, and command buffers, as well as submitting
// command buffers for execution on the device.
class renderer {
public:
  // Create a new renderer. If ec is true, then an error occurred during
  // creation and the renderer object is in an invalid state.
  static renderer create(gsl::czstring application_name, renderer_options opts,
                         PFN_vkDebugReportCallbackEXT debug_report_callback,
                         uint32_t push_constant_size,
                         std::error_code& ec) noexcept;

  // Create a new surface. If ec is true, then an error occurred during
  // creation and the surface object is in an invalid state.
  surface create_surface(wsi::window const& window,
                         std::error_code& ec) noexcept;

  // Resize a surface. Must be called when the window that was passed for
  // surface creation is resized. This is not automatically done to allow
  // the render loop to determine when to perform the resize. If ec is true,
  // then an error occurred during the resize.
  void resize(surface& s, wsi::extent2d const& extent,
              std::error_code& ec) noexcept;

  // Acquire the next ready image in the swapchain for rendering to. This
  // must be called and the returned index passed to submit_present. If
  // ec is true, then an error occurred and the returned index is invalid.
  uint32_t acquire_next_image(surface& s, std::error_code& ec) noexcept;

  // Submit a set of command buffers for execution and then present the
  // previously acquired swapchain image. image_index must come from an
  // immediately preceding call to acquire_next_image. fence can be
  // VK_NULL_HANDLE which indicates no fence should be signaled when the
  // command buffers can be reused. If ec is true, then an error occurred
  // during either the submit or present.
  void submit_present(gsl::span<VkCommandBuffer> buffers, surface& s,
                      uint32_t image_index, VkFence fence,
                      std::error_code& ec) noexcept;

  void destroy(surface& s) noexcept;

private:
  void release(surface& s) noexcept;

public:
  // Allocate a set of command buffers. If ec is true, then an error occurred
  // and the vector is invalid.
  std::vector<VkCommandBuffer>
  allocate_command_buffers(uint32_t count, std::error_code& ec) noexcept;

  // Submit a set of command buffers. onetime indicates that the submit should
  // use the onetime fence and wait for the submit to complete before
  // continuing. If ec is true, then an error occurred.
  void submit(gsl::span<VkCommandBuffer> command_buffers, bool onetime,
              std::error_code& ec) noexcept;

  void free(std::vector<VkCommandBuffer>& command_buffers) noexcept;

  // Create a new shader from the given source code. path is expected to hold
  // GLSL source code which will be compiled before creating the shader. If ec
  // is true, then an error occurred and the shader is valid such that
  // shader::error_message can be called to get any compilation errors.
  shader create_shader(plat::filesystem::path const& path, shader::types type,
                       std::error_code& ec) noexcept;

  void destroy(shader& s) noexcept;

  // Create a new pipeline layout. If ec is true, then an error occurred and
  // the pipeline layout object is invalid.
  VkPipelineLayout create_pipeline_layout(
    gsl::span<VkDescriptorSetLayout> descriptor_set_layouts,
    gsl::span<VkPushConstantRange> push_constant_ranges,
    std::error_code& ec) noexcept;

  void destroy(VkPipelineLayout layout) noexcept;

  // Create a new set of pipelines. A single pipeline can also be created.
  // If ec is true, then an error occurred and the vector of pipelines is
  // invalid.
  std::vector<VkPipeline>
  create_pipelines(gsl::span<VkGraphicsPipelineCreateInfo> cinfos,
                   std::error_code& ec) noexcept;

  void destroy(gsl::span<VkPipeline> pipes) noexcept;

  // Create a new fence. If ec is true, then an error occurred and the fence
  // is invalid.
  VkFence create_fence(bool signaled, std::error_code& ec) noexcept;

  // Wait for a set of fences to be signaled. If wait_all is true, then all
  // fences must be signaled before the call will return, if wait_all is
  // false, then a single fence will cause the call to return. timeout
  // specifies how long to wait, 0 returns immediately, and UINT64_MAX will
  // wait indefinitely. If ec is true, and error occurred while waiting.
  void wait(gsl::span<VkFence> fences, bool wait_all, uint64_t timeout,
            std::error_code& ec) noexcept;

  // Reset a set of fences from the signaled state to unsignaled. If ec is
  // true then an error occured.
  void reset(gsl::span<VkFence> fences, std::error_code& ec) noexcept;

  void destroy(VkFence fence) noexcept;

  constexpr renderer() noexcept {};
  renderer(renderer const&) = delete;
  renderer(renderer&& other) noexcept;
  renderer& operator=(renderer const&) = delete;
  renderer& operator=(renderer&& rhs) noexcept;
  ~renderer() noexcept;

private:
  VkInstance _instance{VK_NULL_HANDLE};
  VkDebugReportCallbackEXT _callback{VK_NULL_HANDLE};

  VkPhysicalDevice _physical{VK_NULL_HANDLE};
  VkDevice _device{VK_NULL_HANDLE};

  uint32_t _graphics_queue_family_index{UINT32_MAX};
  VkQueue _graphics_queue{VK_NULL_HANDLE};
  VkCommandPool _graphics_command_pool{VK_NULL_HANDLE};
  VkFence _graphics_onetime_fence{VK_NULL_HANDLE};
}; // class renderer

inline constexpr auto operator|(renderer_options a,
                                renderer_options b) noexcept {
  using U = std::underlying_type_t<renderer_options>;
  return static_cast<renderer_options>(static_cast<U>(a) | static_cast<U>(b));
}

inline constexpr auto operator&(renderer_options a,
                                renderer_options b) noexcept {
  using U = std::underlying_type_t<renderer_options>;
  return static_cast<renderer_options>(static_cast<U>(a) & static_cast<U>(b));
}

#endif // VKST_RENDERER_H


can we get the service task control from flowable engin.
so that we can complete whenever we want it.
i have to use a service task to call an external REST service, i dont l know when that REST service will complete.
for that i need to wait till in service task.
And one more question is i have created one process like,
Start Event -> UserTask -> ServiceTask -> UserTask -> EndEvent
when i am completing a first userTask it is not completing but that contol is going to serviceTask and it executing a serviceTask Class.
please help ASAP.


Wilbur the pig now wants to play with strings. He has found an n by m table consisting only of the digits from 0 to 9 where the rows are numbered 1 to n and the columns are numbered 1 to m. Wilbur starts at some square and makes certain moves. If he is at square (x, y) and the digit d (0 ≤ d ≤ 9) is written at position (x, y), then he must move to the square (x + ad, y + bd), if that square lies within the table, and he stays in the square (x, y) otherwise. Before Wilbur makes a move, he can choose whether or not to write the digit written in this square on the white board. All digits written on the whiteboard form some string. Every time a new digit is written, it goes to the end of the current string.

Wilbur has q strings that he is worried about. For each string si, Wilbur wants to know whether there exists a starting position (x, y) so that by making finitely many moves, Wilbur can end up with the string si written on the white board.


I was trying to compare ffmpeg 5.0 vs version 3.4.6 in how much performance improvements I would get while transcoding a simple 720p video into a H264 video. On my laptop, I noticed around 5-10% improvement in the total execution time when using the updated version.
ffmpeg -y -i video.webm -r 30 -vf eq=gamma=.95:saturation=1.1,scale=w=960:h=540:force_original_aspect_ratio=decrease -c:v libx264 -profile:v high -level 4.2 -crf 25 -tune film -b:a 128k -ar 44100 -async 1 -movflags +faststart -max_muxing_queue_size 9999 output.mp4
Should I really expect a performance improvement when using this updated version? And are there any other flags or ways I can add to improve performance or quality even more?


You are given an undirected, connected graph of $$$n$$$ nodes and $$$m$$$ edges. All nodes $$$u$$$ of the graph satisfy the following:

- Let $$$S_u$$$ be the set of vertices in the longest simple cycle starting and ending at $$$u$$$.
- Let $$$C_u$$$ be the union of the sets of vertices in any simple cycle starting and ending at $$$u$$$.
- $$$S_u = C_u$$$.

You need to answer $$$q$$$ queries.

For each query, you will be given node $$$a$$$ and node $$$b$$$. Out of all the edges that belong to any simple path from $$$a$$$ to $$$b$$$, count the number of edges such that if you remove that edge, $$$a$$$ and $$$b$$$ are reachable from each other.


Pune | Full Time
We are building the future, one classroom at a time.
CleverGround is an education infrastructure startup and the creator of the largest global teaching-exclusive platform. We have enabled millions of educators in India and across the globe digitize their classrooms with our proprietary, mobile-first, classroom technology.
We are a team of young, enterprising leaders with experience working at some of India’s leading startups over the years. Innovation, ownership and passion is at the heart of everything we do and we are all unified by the single mission of democratizing education by empowering educators and enabling them to create impactful learning experiences.
About the role – Backend Engineer at CleverGround:
CleverGround is looking for a Senior Backend Engineer to help us scale for our continued growth as a game-changing, industry-defining company shaping the future of education.
- Development of our application’s back end. End to end delivery of new features.
- Evolving the architecture for performance and scalability.
- Design, develop and own components of a highly scalable, distributed web services platform.
- Constantly strive to improve software development process and team productivity.
- 3+ years of experience in backend development
- Proficient in python and Django/flask
- Experience with databases like MongoDB, Postgres, Redis
- Experience with Stream processing software like Kafka
- Algorithms and software design optimized for large scale distributed software systems
Good to have
- Experience with Spark/Pandas
- Have experience with Google Cloud Platform/ AWS
- Knowledge of Other languages like C++/Java
Must-have Mindsets And Skillsets
- Strong algorithmic thinking
- Seamless Collaboration with Mobile and Web Development team
- Solid foundation in Computer Science, with strong competencies in data structures,


i am having problems downloading with torrents at speed, the maximum i seem to be getting on any torrent is 7kb/s. regardless of the seeder/leecher ratio. I recently upgraded my pc and thus installed windows on a new hdd. Before i upgraded i was getting the full speed of 2mb (around 230kb/s) and i wasnt connectable. I cant become connectable because i am living in halls of residence and i think there is a firewall somewhere down the line. (I have a LAN socket in my wall for internetl). I am using Sygate Personal Firewall with the same set-up as i had before, and as far as im concerned i have exactly the same software set up as before. Im using Bittornado, which i have never had a problem with.
Could it be my LAN adapter drivers? It seems to be the only thing that i have changed. Im using a new MSI k9ngm motherboard which uses Nvidia network drivers (Nvidia C51G/C51PV chipset i think). I have also got a new program running through my firewall; NDIS user mode I/O driver?!
I have checked all options regarding restricting speed and spent hours configuring my computer to try and get this working...please dont tell me to go to portforward.com!!
Any help appreciated