Find A Group

{"map_options":{"center_lat":51.6626281,"center_lng":-3.8037925,"zoom":5,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/csrf.org.uk\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https:\/\/csrf.org.uk\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/icons\/1-generic.png","infowindow_setting":"<div class=\"fc-main\">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div>\n<div class=\"fc-item-featured_image\">{marker_image} <\/div>\n<p>{marker_message}<\/p>\n<address><b>Address : <\/b>{marker_address}<\/address>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!--{post_featured_image}-->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\">{post_categories}<\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">{post_title}<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"{post_link}\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-main&quot;&gt;&lt;div class=&quot;fc-item-title&quot;&gt;{marker_title} &lt;span class=&quot;fc-badge info&quot;&gt;{marker_category}&lt;\/span&gt;&lt;\/div&gt; &lt;div class=&quot;fc-item-featured_image&quot;&gt;{marker_image} &lt;\/div&gt;{marker_message}&lt;address&gt;&lt;b&gt;Address : &lt;\/b&gt;{marker_address}&lt;\/address&gt;&lt;\/div&gt;"},"infowindow_post_skin":{"name":"udine","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;!--{post_featured_image}--&gt;\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n            &lt;div class=&quot;fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center&quot;&gt;{post_categories}&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color fc-text-center&quot;&gt;{post_title}&lt;\/div&gt;\r\n&lt;div class=&quot;post-link&quot;&gt;&lt;a class=&quot;w-btn us-btn-style_1&quot; href=&quot;{post_link}&quot;&gt;View Group&lt;\/a&gt;&lt;\/div&gt;\r\n           &lt;!-- &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {post_excerpt}\r\n            &lt;\/div&gt; --&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":true,"default_infowindow_open":false,"infowindow_open_event":"click","infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"search_placeholder":"Enter a location","bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"600","google_fonts":["Lato"]},"places":[{"source":"post","title":"Neath Port Talbot","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Neath Port Talbot<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/neath-port-talbot\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","content":"","address":"Neath Community Centre 10-12 Orchard Street Neath SA11 1DU","location":{"lat":51.6626281,"lng":-3.8037925,"redirect_custom_link":"","onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/neath-port-talbot\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMr W Pugh Chairperson T: 01792 864299\r\nMrs M Potter Secretary T: 01639 793896\r\nMr H Pattrick MBE Treasurer T: 01639 720662\r\n<h3>Address<\/h3>\r\nNeath Community Centre\r\n10-12 Orchard Street\r\nNeath\r\nSA11 1DU\r\n<h3>Meetings<\/h3>\r\nLast Monday of each month at 2pm (except where there is a Bank Holiday)\r\n<h3>Events<\/h3>\r\n25 Dec No meeting\r\n29 Jan 2024 A.G.M.[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Neath Port Talbot","post_link":"https:\/\/csrf.org.uk\/group\/neath-port-talbot\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Neath Community Centre 10-12 Orchard Street Neath SA11 1DU, 51.6626281, -3.8037925, 14, ChIJizW6osxdbkgRAOyZaIjYL4Y, 10-12, Orchard Street, Orchard St, Neath, Wales, SA11 1DU, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_edit_lock%":"1698848939:3","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":406,"custom_filters":[],"infowindow_disable":false},{"source":"post","title":"Cardiff","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Cardiff<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/cardiff\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Ararat Baptist Church Plas Treoda, Whitchurch Cardiff South Glamorgan CF14 1PT","location":{"lat":51.51064720000001,"lng":-3.2110921,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/cardiff\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nJane Lewis Secretary T: 029 20 757174\r\n<h3>Address<\/h3>\r\nArarat Baptist Church\r\nPlas Treoda, Whitchurch\r\nCardiff\r\nSouth Glamorgan\r\nCF14 1PT\r\n<h3>Meetings<\/h3>\r\nFirst Wednesday of the month at 10.30am\r\n<h3>Events<\/h3>\r\nWe meet monthly for coffee in the cafe at the Ararat Baptist Church[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Cardiff","post_link":"https:\/\/csrf.org.uk\/group\/cardiff\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698849001:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Ararat Baptist Church Plas Treoda, Whitchurch Cardiff South Glamorgan CF14 1PT, 51.5106472, -3.2110921, 10, ChIJG5zTqncbbkgR4YKcpX0CgW8, Plas Treoda, Cardiff, Cymru, CF14 1PT, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":405,"infowindow_disable":false},{"source":"post","title":"Caerphilly","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Caerphilly<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/caerphilly\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"No.2 Meeting Room Caerphilly New Library The Twyn Caerphilly CF83 1JL","location":{"lat":51.5745924,"lng":-3.2174432,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/caerphilly\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMr Brian Leach, Event\/Speaker Organiser Tel: 01873 881022\r\nE: <a href=\"mailto:brian_leach253@btinternet.com\">brian_leach253@btinternet.com<\/a>\r\n<h3>Address<\/h3>\r\nNo.2 Meeting Room\r\nCaerphilly New Library\r\nThe Twyn\r\nCaerphilly\r\nCF83 1JL\r\n<h3>Meetings<\/h3>\r\nSecond Monday of every month at 10.15am (no meeting in August)\r\n<h3>Events<\/h3>\r\n08 Jan 2024\u00a0 \u00a0 \u00a0 Guide Dogs - Sue Sims\r\n12 Feb\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0AGM &amp; Quiz\r\n11 Mar\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Talk: Digging for Gold - Jimmy Stokes\r\n08 Apr\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Talk: Save the Children - Ann Jackson\r\n13 May\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Talk: Age Cymru - Kathy Lye\r\n10 Jun\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Summer Trip\r\n08 Jul\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Summer Lunch\r\n09 Sept\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Talk: The Impact of Autism - Glyn Roberts\r\n14 Oct\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0TBC\r\n11 Nov\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Bring &amp; Buy Morning\r\n09 Dec\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Christmas Lunch[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Caerphilly","post_link":"https:\/\/csrf.org.uk\/group\/caerphilly\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698849369:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"No.2 Meeting Room Caerphilly New Library The Twyn Caerphilly CF83 1JL, 51.5745924, -3.2174432, 14, ChIJmSx22EcZbkgRbnoZsWsu0Z0, Caerphilly, Wales, Caerphilly, CF83 1NX, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":404,"infowindow_disable":false},{"source":"post","title":"Inverness","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Inverness<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/inverness\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Red Pepper Cafe 92 Academy Street Inverness IV1 1LU","location":{"lat":57.4804092,"lng":-4.2268302,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/inverness\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMrs Pam Barnet T: 01463 790265\r\n<h3>Address<\/h3>\r\nRed Pepper Cafe\r\n92 Academy Street\r\nInverness\r\nIV1 1LU\r\n<h3>Meetings<\/h3>\r\nFirst Wednesday of each month, coffee morning at 11am\r\n<h3>Events<\/h3>\r\n<h3>Local News<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Inverness","post_link":"https:\/\/csrf.org.uk\/group\/inverness\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698849421:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Red Pepper Cafe 92 Academy Street Inverness IV1 1LU, 57.4804092, -4.2268302, 14, ChIJrQJJ5VJxj0gRMn_aN5aroR0, Academy Street, Academy St, Inverness, Scotland, IV1 1LU, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":403,"infowindow_disable":false},{"source":"post","title":"Edinburgh","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Edinburgh<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/edinburgh\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Mercure Hotel, Princes Street, Edinburgh EH2 2DG","location":{"lat":55.952765,"lng":-3.1944145,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/edinburgh\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nLiz Beedie Chair T: 0131 229 7422\r\nTrudy Thomas Deputy Chair T: 0131 346 0208\r\nFrancis Valentine Treasurer T: 0131 228 3243\r\n(Walks Co-Ordinator)\r\nJean Robertson Committee Member T: 0131 661 8760\r\n(Days Away Co-Ordinator)\r\n<h3>Address<\/h3>\r\nMercure Hotel, Princes Street, Edinburgh EH2 2DG\r\n<h3>Meetings<\/h3>\r\nThird Tuesday of each month at 2pm (No meetings in August or December and in January (Winter Lunch) and September (Summer Lunch)).\r\n\r\nWe run walks throughout the year and meet at Lakeland, corner of George Street\/Hanover Street at 1.30pm on the first Friday of each month (except May &amp; August). Organiser: Francis Valentine (Tel: 0131 228 3243).\r\n\r\nWe also run days away in May and August. Organiser: Jean Robertson (Tel: 0131 661 8760)\r\n<h3>Events<\/h3>\r\n16th Jan 2024 Winter Lunch, 12.30pm (Venue tba)\r\n20 Feb Coffee &amp; Chat at the Mercure Hotel\r\n19 Mar Coffee &amp; Chat at the Mercure Hotel\r\n\r\n<strong>Walks\/Days Away<\/strong>\r\nContact for Walks Francis Valentine 0131 228 3243\r\nContact for Days Away Jean Robertson 0131 661 8760\r\n\r\n01 Dec Walk - meet Lakeland Corner, George Street 1.30pm\r\n02 Feb 2024 Walk - meet Lakeland Corner, George Street 1.30pm\r\n01 Mar Walk - meet Lakeland Corner, George Street 1.30pm[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Edinburgh","post_link":"https:\/\/csrf.org.uk\/group\/edinburgh\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698849575:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Mercure Hotel, Princes Street, Edinburgh EH2 2DG, 55.952765, -3.1944145, 14, ChIJTUqATJDHh0gRDekrycqCrDs, Princes Street, Princes St, Edinburgh, Scotland, EH2 2DG, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":402,"infowindow_disable":false},{"source":"post","title":"Lisburn","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lisburn<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/lisburn\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Bridge Community Centre 50 Railway Street Lisburn County Antrim BT28 1XP","location":{"lat":54.513456,"lng":-6.0442709,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/lisburn\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMrs R Hope - Secretary - Tel: 028 9268 3610\r\n<h3>Address<\/h3>\r\nBridge Community Centre\r\n50 Railway Street\r\nLisburn\r\nCounty Antrim\r\nBT28 1XP\r\n<h3>Meetings<\/h3>\r\nSecond Monday of each month at 2.30pm (except July and August)\r\n<h3>Events<\/h3>\r\n08 Jan Annual General Meeting in Bridge Community Centre, 2.30pm\r\n12 Feb Meeting in Bridge Community Centre, 2.30pm\r\nSpeaker: Rev David Kerr on the subject 'The Royals'\r\n11 Mar Visit to Hillside Garden Centre, Newtownabbey with lunch in their cafe\r\nPick up time 11.30am at Lisburn Leisure Centre\r\n08 Apr Visit to Antrim Castle Gardens &amp; Clotworthy House with lunch in Diana's Tea Rooms\r\nPick up time 11am at Lisburn Leisure Centre (please note earlier time)\r\n13 May Lunch in the Wildfowler, Greyabbey with browsing time in Antique Shops\r\nPick up time 11.30am at Lisburn Leisure Centre\r\n10 Jun Summer Lunch, Mulberry Tree, Seaforde then a visit to Newcastle\r\nPick up time 11.30am at Lisburn Leisure Centre[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Lisburn","post_link":"https:\/\/csrf.org.uk\/group\/lisburn\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1702989422:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Bridge Community Centre 50 Railway Street Lisburn County Antrim BT28 1XP, 54.513456, -6.0442709, 14, ChIJIy8xM10EYUgR6BSadCpLhRo, 50, Railway Street, Railway St, Lisburn, Northern Ireland, BT28 1XP, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":401,"infowindow_disable":false},{"source":"post","title":"Craigavon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Craigavon<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/craigavon\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Portadown Town Hall 15 Edward St, Portadown, Craigavon BT62 3LX","location":{"lat":54.4223505,"lng":-6.442027899999999,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/craigavon\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nGeorge McConnell Secretary T: 028 8676 4395\r\nE: <a href=\"mailto:joannearcher1@hotmail.co.uk\">joannearcher1@hotmail.co.uk<\/a>\r\n<h3>Address<\/h3>\r\nPortadown Town Hall\r\n15 Edward St,\r\nPortadown,\r\nCraigavon BT62 3LX\r\n<h3>Meetings<\/h3>\r\nFirst Tuesday of the month at 2.30pm\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Craigavon","post_link":"https:\/\/csrf.org.uk\/group\/craigavon\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698910646:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Portadown Town Hall 15 Edward St, Portadown, Craigavon BT62 3LX, 54.4223505, -6.4420279, 14, ChIJX54PEsTvYEgRZUnzvjGmFQ8, 15, Edward Street, Edward St, Craigavon, Northern Ireland, BT62 3LX, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":400,"infowindow_disable":false},{"source":"post","title":"Banbridge","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Banbridge<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/banbridge\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Bannside Presbyterian Church Hall 21 Castlewellan Road Banbridge BT32 4AX","location":{"lat":54.3495654,"lng":-6.2660493,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/banbridge\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMargaret Hassan Secretary T: 07884 073401\r\nMichael Wailes Chairman T: 028 4062 7744\r\n<h3>Address<\/h3>\r\nBannside Presbyterian Church Hall\r\n21 Castlewellan Road\r\nBanbridge\r\nBT32 4AX\r\n<h3>Meetings<\/h3>\r\nFirst Wednesday of the month at 2pm (except June, July and August)\r\n<h3>Events<\/h3>\r\n06 Dec\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Christmas Party\r\n03 Jan 2024\u00a0 \u00a0Armchair Aerobics with Eileen Hughes\r\n07 Feb\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Storytelling with Liz Weir\r\n06 Mar\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Ring of Gullion: Illustrated Talk by Una Walsh\r\n03 Apr\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Local Nature Illustrated Talk by David McCreery\r\n01 May\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Annual General Meeting\r\n05 Jun\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Summer Tea Party &amp; Coach Trip[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Banbridge","post_link":"https:\/\/csrf.org.uk\/group\/banbridge\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698913753:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Bannside Presbyterian Church Hall 21 Castlewellan Road Banbridge BT32 4AX, 54.3495654, -6.2660493, 14, ChIJ9wCwa1LhYEgRafaLVh3-xTg, 21, Castlewellan Road, Castlewellan Rd, Banbridge, Northern Ireland, BT32 4AZ, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":399,"infowindow_disable":false},{"source":"post","title":"Belfast","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Belfast<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/belfast\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"McElhinney Room, The Pavillion, Stormont Estate Upper Newtownards Road Belfast BT4 3TA","location":{"lat":54.6008844,"lng":-5.8297039,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/belfast\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMiss Wynne O'Neill Secretary T: 028 9067 1157\r\n<h3>Address<\/h3>\r\nMcElhinney Room, The Pavillion, Stormont Estate\r\nUpper Newtownards Road\r\nBelfast\r\nBT4 3TA\r\n<h3>Meetings<\/h3>\r\nFirst Monday of each month at 2pm (except June, July and August)\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Belfast","post_link":"https:\/\/csrf.org.uk\/group\/belfast\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1693586348:2","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"McElhinney Room, The Pavillion, Stormont Estate Upper Newtownards Road Belfast BT4 3TA, 54.6008844, -5.8297039, 18, ChIJt7sBK7ULYUgRZ8tFi2zrE9Y, Belfast, Northern Ireland, BT4 3TA, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":398,"infowindow_disable":false},{"source":"post","title":"Ascot &#038; Sunningdale","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Ascot &#038; Sunningdale<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/ascot-sunningdale\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Lynwood Village Rise Road Sunninghill Ascot SL5 0AJ","location":{"lat":51.3986999,"lng":-0.6456214,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/ascot-sunningdale\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nGraeme Holt Chairman T: 01344 48170\r\nE: <a href=\"mailto:graemecholt@gmail.com\">graemecholt@gmail.com<\/a>\r\n<h3>Address<\/h3>\r\nLynwood Village\r\nRise Road\r\nSunninghill\r\nAscot SL5 0AJ\r\n<h3>Meetings<\/h3>\r\nThird Friday of each month at 1pm - 4.00pm (except August) - lunch at 1pm followed by meeting at 2pm (lunch has to pre-ordered)\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Ascot &#038; Sunningdale","post_link":"https:\/\/csrf.org.uk\/group\/ascot-sunningdale\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698911077:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Lynwood Village Rise Road Sunninghill Ascot SL5 0AJ, 51.3986999, -0.6456214, 14, ChIJqahtmzp5dkgRFZ2kgBWzx-A, Rise Road, Rise Rd, Ascot, England, SL5 0FG, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":397,"infowindow_disable":false},{"source":"post","title":"Banbury","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Banbury<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/banbury\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Hanwell Fields Community Centre Rotary Way Banbury OX16 1ER","location":{"lat":52.0787043,"lng":-1.3464192,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/banbury\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nSue Atherton Chairperson T: 01295 252304\r\nSandra Holmes Treasurer T: 01295 750327\r\n<h3>Address<\/h3>\r\nHanwell Fields Community Centre\r\nRotary Way\r\nBanbury\r\nOX16 1ER\r\n<h3>Meetings<\/h3>\r\nSecond Thursday of each month at 2.30pm\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Banbury","post_link":"https:\/\/csrf.org.uk\/group\/banbury\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698911147:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Hanwell Fields Community Centre Rotary Way Banbury OX16 1ER, 52.0787043, -1.3464192, 14, ChIJW9at9Bcmd0gRVqZ-D6akaBY, Rotary Way, Banbury, England, OX16 1ER, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":396,"infowindow_disable":false},{"source":"post","title":"Basingstoke","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Basingstoke<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/basingstoke\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Brookvale Community Association Hall Lower Brook Street Basingstoke RG21 7SD","location":{"lat":51.26613649999999,"lng":-1.0967561,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/basingstoke\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nTony Brazier Secretary T: 01256 418770\r\nE: <a href=\"mailto:bjmapbr@ntlworld.com\">bjmapbr@ntlworld.com<\/a>\r\nDavid Cowling Chairman T: 01256 327806\r\n<h3>Address<\/h3>\r\nBrookvale Community Association Hall\r\nLower Brook Street\r\nBasingstoke\r\nRG21 7SD\r\n<h3>Meetings<\/h3>\r\nFirst Wednesday of each month at 10am (except Jan when it is the second Weds)\r\nPlease note that all trips will be subject to a minimum number of bookings.\r\n<h3>Events<\/h3>\r\n<div>07 Feb 2024 The Beekeeper - talk by Fred Swift<\/div>\r\n<div>06 Mar AGM followed by talk by Peter Robinson (Neighbourcare Basingstoke) followed by lunch at the Conservative Club<\/div>\r\n<div>03 Apr Should we follow the leader? Leadership in Challenging Times - talk by Daniel Cowling<\/div>\r\n<div>01 May Gardening and Disabled Helpers - talk by Thrive<\/div>\r\n<div>05 Jun Willis Museum - talk by John Hollands<\/div>\r\n<div>03 Jul Henry VIII - talk by Tony Harris<\/div>\r\n<div>07 Aug Sex Lives of Kings - talk by Tony Strafford<\/div>\r\n<div>04 Sept Naomi House, Jacks' Place<\/div>\r\n<div>02 Oct Sweeney Todd, Romance and Retribution - talk by Steve Herra<\/div>\r\n<div>06 Nov 2nd Part Somebody - talk by Alan Jones<\/div>\r\n<div>04 Dec Christmas Party<\/div>\r\n<div><\/div>\r\n<div><\/div>\r\n<div><strong>Proposed 2024 Outings<\/strong><\/div>\r\n<div><\/div>\r\n<div>18 Apr Arundel Castle<\/div>\r\n<div>23 May Savill Gardens<\/div>\r\n<div>20 Jun Afternoon Tea at BCOT<\/div>\r\n<div>18 Jul Wisley Gardens<\/div>\r\n<div>12 Sept River Trip<\/div>\r\n<div>17 Oct Mystery Trip - Historic Hampshire<\/div>\r\n<div>12 Dec Christmas Lunch at BCoT<\/div>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Basingstoke","post_link":"https:\/\/csrf.org.uk\/group\/basingstoke\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698911164:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Brookvale Community Association Hall Lower Brook Street Basingstoke RG21 7SD, 51.2661365, -1.0967561, 14, ChIJTZiyVY4hdEgRY43NWwSl4VE, Lower Brook Street, Lower Brook St, Basingstoke, England, RG21 7RP, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":395,"infowindow_disable":false},{"source":"post","title":"Bexhill &#038; Hastings","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Bexhill &#038; Hastings<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/bexhill-hastings\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Bexhill Sailing Club De La Warr Parade Bexhill-on-Sea TN40 1LA","location":{"lat":50.8377225,"lng":0.4771112999999999,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/bexhill-hastings\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nElizabeth Leahy Secretary T: 01424 214042\r\nMichael Price Chairman T: 01424 734200\r\nBrian Thring Vice Chairman T: 01424 215686\r\nPhyl McEwan Treasurer T: 01424 219589\r\nRosemary Siepmann Welfare Officer T: 01424 217090\r\n<h3>Address<\/h3>\r\nBexhill Sailing Club\r\nDe La Warr Parade\r\nBexhill-on-Sea\r\nTN40 1LA\r\n<h3>Meetings<\/h3>\r\nFourth Tuesday of each month at 10.00am (except December)\r\n<h3>Events<\/h3>\r\n23 Jan Quiz\r\n27 Feb AGM\r\n26 Mar Talk Burton's St Leonards by Ken Brooks\r\n23 Apr Talk 35 Years as an Independent Tour Operator by Clive Richardson\r\n28 May Talk Marie Curie charity by Chloe Woolfe\r\n25 June Talk Humanimal Trust by Catherine Stringer\r\n23 July Quiz\r\n27 August Talk E Sussex Wildlife Rescue &amp; Ambulance Service by Trevor Weeks MBE\r\n24 September Talk Help 4 Hedgehogs Herstmonceaux\r\n22 October Talk Crime, Punishment &amp; Smuggling in E Sussex by Robert Slater\r\n26 November Talk The High Weald - 3 Castles &amp; an Ironmasters House by David Clarke\r\nDecember Xmas lunch TBA[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Bexhill &#038; Hastings","post_link":"https:\/\/csrf.org.uk\/group\/bexhill-hastings\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1705507478:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Bexhill Sailing Club De La Warr Parade Bexhill-on-Sea TN40 1LA, 50.8377225, 0.4771113, 14, ChIJ6_FOcSEO30cRMlVFyCVctOQ, De La Warr Parade, Bexhill-on-Sea, England, TN40, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":394,"infowindow_disable":false},{"source":"post","title":"Bradford-on-Avon","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Bradford-on-Avon<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/bradford-on-avon\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"United Reformed Church Hall St. Margarets Street Bradford-on-Avon BA15 1DD","location":{"lat":51.3451894,"lng":-2.2513518,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/bradford-on-avon\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMr M Wickham Secretary T: 01225 864541\r\nE: <a href=\"mailto:lindamorgan1975@sky.com\">lindamorgan1975@sky.com<\/a>\r\n<h3>Address<\/h3>\r\nUnited Reformed Church Hall\r\nSt. Margarets Street\r\nBradford-on-Avon\r\nBA15 1DD\r\n<h3>Meetings<\/h3>\r\nSecond Monday of each month from 2.15pm to 4pm (except August)\r\n<h3>Events<\/h3>\r\nDec tbc Christmas Lunch\r\n08 Jan 2024 New Year Social (self catering)\r\n12 Feb AGM[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Bradford-on-Avon","post_link":"https:\/\/csrf.org.uk\/group\/bradford-on-avon\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698911478:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"United Reformed Church Hall St. Margarets Street Bradford-on-Avon BA15 1DD, 51.3451894, -2.2513518, 14, EitTdCBNYXJnYXJldCdzIFN0LCBCcmFkZm9yZC1vbi1Bdm9uIEJBMTUsIFVLIi4qLAoUChIJOVmiy8l_cUgRvw34hHO0hu8SFAoSCZ0tbcjJf3FIEfD9bi0IDsFI, Saint Margaret's Street, St Margaret's St, Bradford-on-Avon, England, BA15, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":393,"infowindow_disable":false},{"source":"post","title":"Chippenham","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Chippenham<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/chippenham\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Chippenham Museum 10 Market Place Chippenham SN15 3HF","location":{"lat":51.45748159999999,"lng":-2.1144068,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/chippenham\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nDavid Gardner Chairman T: 01249 658431\r\nGladys Webster Secretary T: 01249 816719 E: <a href=\"mailto:gladyswebster@sky.com\">gladyswebster@sky.com<\/a>\r\n<h3>Address<\/h3>\r\nChippenham Museum\r\n10 Market Place\r\nChippenham\r\nSN15 3HF\r\n<h3>Meetings<\/h3>\r\nFirst Wednesday of each month at 2pm (except January, August and December)\r\n<h3>Events<\/h3>\r\n<h3>Local News<\/h3>\r\nWe organise a lunch every 2 months at various venues - further details from Secretary.[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Chippenham","post_link":"https:\/\/csrf.org.uk\/group\/chippenham\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698911550:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Chippenham Museum 10 Market Place Chippenham SN15 3HF, 51.4574816, -2.1144068, 14, ChIJA8aSHdd6cUgRVmpNLZtaUqc, 9-10, Market Place, Market Pl, Chippenham, England, SN15 3HF, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":392,"infowindow_disable":false},{"source":"post","title":"Coalville &#038; Ashby","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Coalville &#038; Ashby<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/coalville-ashby\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Thringstone Community Centre The Green, Thringstone Coalville LE67 8NR","location":{"lat":52.7509679,"lng":-1.3685852,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/coalville-ashby\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nTerry Watson Chairman T: 01530 835373\r\n<h3>Address<\/h3>\r\nThringstone Community Centre\r\nThe Green, Thringstone\r\nCoalville\r\nLE67 8NR\r\n<h3>Meetings<\/h3>\r\nThird Wednesday each month 2pm - 4pm\r\n<h3>Events<\/h3>\r\n13 Dec Christmas Meal[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Coalville &#038; Ashby","post_link":"https:\/\/csrf.org.uk\/group\/coalville-ashby\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698911580:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Thringstone Community Centre The Green, Thringstone Coalville LE67 8NR, 52.7509679, -1.3685852, 14, ChIJi2y3dT3jeUgR-n7d2LCNEnc, 26, The Green, The Grn, Coalville, England, LE67 8NR, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":391,"infowindow_disable":false},{"source":"post","title":"Colchester","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Colchester<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/colchester\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Hythe Community Centre 1 Ventura Drive Colchester CO1 2FE","location":{"lat":51.88364809999999,"lng":0.9240843999999998,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/colchester\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nJoan Gomer Secretary T: 01206 794656\r\n<h3>Address<\/h3>\r\nHythe Community Centre\r\n1 Ventura Drive\r\nColchester\r\nCO1 2FE\r\n<h3>Meetings<\/h3>\r\nThird Monday of each month at 2pm (except August &amp; December)\r\n<h3>Events<\/h3>\r\n15th Jan 2024\u00a0 \u00a0 Picture Quiz - Joan Gomer\r\n19 Feb\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Annual General Meeting\r\n18 Mar\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Growing up in the Dutch Quarter - Roy Waters\r\n15 Apr\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Pat Farrow reads her poetry\r\n20 May\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 The Civil War in Braintree - Stewart Seymour\r\n17 Jun\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Romany - Joan Gomer\r\n15 Jul\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Fred Pearce Entertains\r\n19 Aug\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Cream Tea - venue to be decided\r\n16 Sept\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 TBA\r\n21 Oct\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 TBA\r\n18 Nov\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0TBA\r\nDec\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Christmas Meal - Date\/venue tba\r\n<h3>Local News<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Colchester","post_link":"https:\/\/csrf.org.uk\/group\/colchester\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1700145639:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Hythe Community Centre 1 Ventura Drive Colchester CO1 2FE, 51.8836481, 0.9240844, 14, ChIJ2xtPYw8F2UcRSEOHAyPWRWM, 1, Ventura Drive, Ventura Dr, Colchester, England, CO1 2FG, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":390,"infowindow_disable":false},{"source":"post","title":"Hounslow","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Hounslow<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/hounslow\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"United Reformed Church Hall 114 Hanworth Road Hounslow TW3 1UF","location":{"lat":51.4676397,"lng":-0.3611774,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/hounslow\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nRoy Woods Chairman T: 020 8230 5533\r\nJane Cocking Secretary T: 020 8568 6159 E: <a href=\"mailto:jane75cocking@hotmail.co.uk\">jane75cocking@hotmail.co.uk<\/a>\r\n<h3>Address<\/h3>\r\nUnited Reformed Church Hall\r\n114 Hanworth Road\r\nHounslow\r\nTW3 1UF\r\n<h3>Meetings<\/h3>\r\nSecond Tuesday of each month 1.30 for 2.00pm\r\n<h3>Events<\/h3>\r\n<h3>Local News<\/h3>\r\nWe are also hoping to book various trips - please contact the Secretary for further details[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Hounslow","post_link":"https:\/\/csrf.org.uk\/group\/hounslow\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698911745:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"United Reformed Church Hall 114 Hanworth Road Hounslow TW3 1UF, 51.4676397, -0.3611774, 14, ChIJVXEKedkMdkgRCYI7pSJ1rD8, 114, Hanworth Road, Hanworth Rd, Hounslow, England, TW3 1UF, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":389,"infowindow_disable":false},{"source":"post","title":"Gloucester\/Hucclecote","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Gloucester\/Hucclecote<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/gloucester-hucclecote\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Christchurch Heron Way Abbeydale, Gloucester GL4 5EQ","location":{"lat":51.8403152,"lng":-2.2050141,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/gloucester-hucclecote\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMrs J Neale, Chairman T: 01452 506949\r\nDiane Howitt Speaker Secretary T: 01452 522752\r\n<h3>Address<\/h3>\r\nChristchurch\r\nHeron Way\r\nAbbeydale, Gloucester\r\nGL4 5EQ\r\n<h3>Meetings<\/h3>\r\nFirst Thursday of the month at 2pm\r\n<h3>Events<\/h3>\r\n07 Dec \u00a0 \u00a0 \u00a0 \u00a0Christmas Lunch\r\n04 Jan 2024 \u00a0 \u00a0New Year's Party\r\n01 Feb \u00a0 \u00a0 \u00a0 \u00a0TAB\r\n01 Mar \u00a0 \u00a0 \u00a0 \u00a0Annual General Meeting[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Gloucester\/Hucclecote","post_link":"https:\/\/csrf.org.uk\/group\/gloucester-hucclecote\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698911843:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Christchurch Heron Way Abbeydale, Gloucester GL4 5EQ, 51.8403152, -2.2050141, 14, ChIJAZEGt40FcUgRAUsFVIEXa2Q, Heron Way, Gloucester, England, GL4 5EQ, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":388,"infowindow_disable":false},{"source":"post","title":"Kingston &#038; District","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Kingston &#038; District<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/kingston-district\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Kingston, london","location":{"lat":51.41233,"lng":-0.300689,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/kingston-district\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nErik Warren Chairman T: 020 8224 1265\r\n<h3>Address<\/h3>\r\n<h3>Meetings<\/h3>\r\nWe get together for ad hoc lunch meetings in the local area - for more information contact the Chair[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Kingston &#038; District","post_link":"https:\/\/csrf.org.uk\/group\/kingston-district\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698911859:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Kingston, london, 51.41233, -0.300689, 14, ChIJU3SYeDcJdkgR7DU-PrIhP0w, Kingston upon Thames, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"Kingston, London","%_additional_map_location%":"field_64f2090a4001b"}},"id":387,"infowindow_disable":false},{"source":"post","title":"Leatherhead &#038; District","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Leatherhead &#038; District<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/leatherhead-district\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"John Rumble Hall, Fetcham Village Hall The Street Fetcham KT22 9QS","location":{"lat":51.2923191,"lng":-0.3560379,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/leatherhead-district\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nAnne Thomson Secretary T: 01372 373258 E: <a href=\"mailto:anner.thomson@talktalk.net\">anner.thomson@talktalk.net<\/a>\r\nBarbara West Chairman T: 01372 373484\r\n<h3>Address<\/h3>\r\nJohn Rumble Hall, Fetcham Village Hall\r\nThe Street\r\nFetcham\r\nKT22 9QS\r\n<h3>Meetings<\/h3>\r\nFirst Friday of each month at 10.00am\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Leatherhead &#038; District","post_link":"https:\/\/csrf.org.uk\/group\/leatherhead-district\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698911883:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"John Rumble Hall, Fetcham Village Hall The Street Fetcham KT22 9QS, 51.2923191, -0.3560379, 14, ChIJlZ9jJpLgdUgR0yE9I5k7anY, The Street, The St, Leatherhead, England, KT22 9QS, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":386,"infowindow_disable":false},{"source":"post","title":"Liskeard &#038; Pensilva","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Liskeard &#038; Pensilva<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/liskeard-pensilva\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Liskeard Public Hall (Emily Hobhouse Room) West Street Liskeard Cornwall PL14 6BW","location":{"lat":50.45569649999999,"lng":-4.4661465,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/liskeard-pensilva\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nPam Ford Chair T: 01579 349147\r\n<h3>Address<\/h3>\r\nLiskeard Public Hall (Emily Hobhouse Room)\r\nWest Street\r\nLiskeard\r\nCornwall\r\nPL14 6BW\r\n<h3>Meetings<\/h3>\r\nLast Wednesday of each month at 10.00am (except December)\r\n<h3>Events<\/h3>\r\n02 Dec \u00a0 \u00a0 \u00a0 \u00a0Outing to Bath Christmas Market\r\n05 Dec \u00a0 \u00a0 \u00a0 \u00a0Christmas Lunch at the Tavern, Liskeard\r\n31 Jan 2024 \u00a0 AGM\r\n28 Feb \u00a0 \u00a0 \u00a0 \u00a0Talk, Caradon Physio-Wellbeing Centre\r\n27 Mar \u00a0 \u00a0 \u00a0 \u00a0Talk, Every Picture Tells A Story, Cornwall Life 150 Years Ago\r\n24 Apr \u00a0 \u00a0 \u00a0 \u00a0Talk, Emily Hobhouse\r\n29 May\u00a0 \u00a0 \u00a0 \u00a0 Talk, Hedgehogs\r\n26 Jun\u00a0 \u00a0 \u00a0 \u00a0 TBA\r\n31 Jul\u00a0 \u00a0 \u00a0 \u00a0 TBA\r\n28 Aug\u00a0 \u00a0 \u00a0 \u00a0 TBA\r\n25 Sept \u00a0 \u00a0 \u00a0 TBA[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Liskeard &#038; Pensilva","post_link":"https:\/\/csrf.org.uk\/group\/liskeard-pensilva\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Liskeard Public Hall (Emily Hobhouse Room) West Street Liskeard Cornwall PL14 6BW, 50.4556965, -4.4661465, 14, ChIJv4S-_3eDbEgRnQtNevPJqJI, 3-5, West Street, West St, Liskeard, England, PL14 6BW, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_edit_lock%":"1698912002:3","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":385,"infowindow_disable":false},{"source":"post","title":"Catford &#038; Lewisham","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Catford &#038; Lewisham<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/catford-lewisham\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"St Laurence Church Hall 37 Bromley Road Catford London SE6 2TS","location":{"lat":51.4426441,"lng":-0.0200489,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/catford-lewisham\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMiss Jane Duffy Chair T:020 8697 2840\r\n<h3>Address<\/h3>\r\nSt Laurence Church Hall\r\n37 Bromley Road\r\nCatford\r\nLondon\r\nSE6 2TS\r\n<h3>Meetings<\/h3>\r\nSecond Tuesday of every month at 10.00am\r\nWe run various activities during coffee mornings such as quizzes, bingo, poetry readings.\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Catford &#038; Lewisham","post_link":"https:\/\/csrf.org.uk\/group\/catford-lewisham\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698912053:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"St Laurence Church Hall 37 Bromley Road Catford London SE6 2TS, 51.4426441, -0.0200489, 14, ChIJJV0ychcCdkgRJH0ci5aUXVk, 37, Bromley Road, Bromley Rd, London, England, SE6 2TS, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":384,"infowindow_disable":false},{"source":"post","title":"Croydon, Dulwich &#038; Norwood","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Croydon, Dulwich &#038; Norwood<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/croydon-dulwich-norwood\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Fox on the Hill, 149 Denmark Hill, Camberwell, London SE5 8EH","location":{"lat":51.46520220000001,"lng":-0.0895657,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/croydon-dulwich-norwood\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nHilary Waterhouse Secretary T: 020 8239 9814\r\nE: <a href=\"mailto:hilary.waterhouse@virginmedia.com\">hilary.waterhouse@virginmedia.com<\/a>\r\n<h3>Address<\/h3>\r\nWe enjoy monthly friendship lunches at The Crown Inn, 28 Wickham Road, Croydon CR0 8BA and the Fox on the Hill, 149 Denmark Hill, Camberwell, London SE5 8EH\r\n<h3>Meetings<\/h3>\r\nFourth Tuesday of each month at 12 noon (except December)\r\n<h3>Events<\/h3>\r\n28 Nov Fox on the Hill, Denmark Hill[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Croydon, Dulwich &#038; Norwood","post_link":"https:\/\/csrf.org.uk\/group\/croydon-dulwich-norwood\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Fox on the Hill, 149 Denmark Hill, Camberwell, London SE5 8EH, 51.4652022, -0.0895657, 14, ChIJGy8KWYYDdkgR3qAadAMQmSw, 149, Denmark Hill, London, England, SE5 8EH, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_edit_lock%":"1698912167:3","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":383,"infowindow_disable":false},{"source":"post","title":"East London &#038; SW Essex","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">East London &#038; SW Essex<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/east-london-sw-essex\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"The Great Spoon of Ilford 114-116 Cranbrook Road Ilford IG2 4LZ","location":{"lat":51.5619019,"lng":0.0689176,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/east-london-sw-essex\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nNeil Keskar Group Leader T: 020 8531 5461\r\n<h3>Address<\/h3>\r\nThe Great Spoon of Ilford\r\n114-116 Cranbrook Road\r\nIlford\r\nIG2 4LZ\r\n<h3>Meetings<\/h3>\r\nThird Monday of the month at 2pm\r\n<h3>Events<\/h3>\r\n18 Sept Coffee &amp; Drinks afternoon\r\n16 Oct Coffee &amp; Drinks afternoon\r\n20 Nov Coffee &amp; Drinks afternoon\r\n11 Dec Coffee &amp; Drinks afternoon[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"East London &#038; SW Essex","post_link":"https:\/\/csrf.org.uk\/group\/east-london-sw-essex\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698912085:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"The Great Spoon of Ilford 114-116 Cranbrook Road Ilford IG2 4LZ, 51.5619019, 0.0689176, 14, ChIJP8VAmfSm2EcRAf-r1_JPw6c, 116, Cranbrook Road, Cranbrook Rd, Ilford, England, IG1 4LZ, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":382,"infowindow_disable":false},{"source":"post","title":"Eltham","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Eltham<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/eltham\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"United Reformed Church, Sherard Hall Court Road Eltham SE9 5AD","location":{"lat":51.4491161,"lng":0.0515933,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/eltham\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nPhyllis Duignan Chair\/Treasurer T: 020 8265 0810\r\nE: <a href=\"mailto:phyllis.duignan@gmail.com\">phyllis.duignan@gmail.com<\/a>\r\nPatricia Pearce President T: 020 8851 1651\r\nSheila Bailey Vice Chair &amp; Outings\/Holiday Organiser\r\nT: 020 8850 7475 E: <a href=\"mailto:sheilabailey14@gmail.com\">sheilabailey14@gmail.com<\/a>\r\nChristine Richardson Speaker Organiser T:020 8859 4417\r\nAlice Jackson Visiting Officer T: 01689 605498\r\nHilary Lawrence Committee Member T: 020 8355 8835\r\n<h3>Address<\/h3>\r\nUnited Reformed Church, Sherard Hall\r\nCourt Road\r\nEltham\r\nSE9 5AD\r\n<h3>Meetings<\/h3>\r\nFourth Thursday of each month at 10am - 12 noon (except December)\r\n<h3>Events<\/h3>\r\n25 Jan Annual General Meeting\r\n08 Feb Coach outing to lunch Catering College, Tonbridge\r\n22 Feb Coffee Morning followed by a talk by John Halligan on \u201cHow Charing got its name\u201d\r\n14 Mar Coach outing to Windsor Castle including (entrance fee of \u00a328)\r\n20 Mar Theatre \u201cSister Act\u201d at the Dominion Theatre, Tottenham Court Rd at 2.30\r\n28 Mar Coffee Morning followed by a talk by Graeme Payne on \u201cQueens\u2019 Consorts of the last 200 years\u201d\r\n11 Apr Coach outing to Wakehurst Place including entrance fee\r\n25 Apr Coffee Morning followed by a talk by Jim Buttress on \u201c70 years in horticulture\u201d\r\n6-10 May Airedales Holiday to Trouville Hotel, Bournemouth\r\n23 May Coffee Morning followed by a talk by Keith Lawrey on \u201cA tale of scholarship and murder\u201d\r\n13 Jun Coach outing to \u201cKentish Lady\u201d Medway River trip including fish &amp; chips lunch (\u00a333)\r\n27 Jun Coffee Morning followed by a talk by Andy Thomas on \u201cCrop circle mystery\u201d\r\n11 Jul Coach outing to Walmer Castle (EH) including entrance and onto Deal\r\n25 Jul Coffee Morning followed by a talk by Barry Day on \u201cRAF during the Battle of Britain\u201d\r\n08 Aug Coach outing to Hastings\r\n22 Aug Coffee Morning followed by a talk by Tony Trinick on \u201cBee keeping\u201d\r\n9-13 Sep Airedales Holiday looking into Warners Littlecote\r\n26 Sep Coffee Morning followed by a talk by Wilf Lower on \u201cLost Empires\u201d\r\n10 Oct Coach outing to Chartwell NT including entrance\r\n24 Oct Coffee Morning followed by a talk by Alan Haines on \u201cThe life and times of Max Miller\u201d\r\n14 Nov Coach outing to Dobbies Garden Centre, Ashford\r\n28 Nov Coffee Morning followed by a talk by Bob Henderson on \u201cThe Royal Naval College\"\r\n05 Dec Coffee Morning with Cards, Bumper Raffle and Mince pies followed by a vocal entertainer Trevor Styles.\r\n12 Dec Christmas Lunch At Sophie\u2019s Choice Restaurant, Sidcup.\r\n<h3>Local News<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Eltham","post_link":"https:\/\/csrf.org.uk\/group\/eltham\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1704956178:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"United Reformed Church, Sherard Hall Court Road Eltham SE9 5AD, 51.4491161, 0.0515933, 14, EhxDb3VydCBSZCwgTG9uZG9uIFNFOSA1QUQsIFVLIi4qLAoUChIJHRayonep2EcRwBhjZQ5hNGoSFAoSCbG6xGJ0qdhHEQnKxxokVSTX, Court Road, Court Rd, London, England, SE9 5AD, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":381,"infowindow_disable":false},{"source":"post","title":"Lowestoft","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Lowestoft<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/lowestoft\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Victoria Hotel, Kirkley Cliff, Lowestoft NR33 0BZ","location":{"lat":52.4634334,"lng":1.74264,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/lowestoft\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMike Chester T: 01502 476629\r\n<h3>Address<\/h3>\r\n<h3>Meetings<\/h3>\r\nOccasional social events throughout the year - contact the Chair for more information\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Lowestoft","post_link":"https:\/\/csrf.org.uk\/group\/lowestoft\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698912290:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Victoria Hotel, Kirkley Cliff, Lowestoft NR33 0BZ, 52.4634334, 1.74264, 14, ChIJ-zyfdEUa2kcRigb9Nrgr0us, Kirkley Cliff Road, Kirkley Cliff Rd, Lowestoft, England, NR33 0BZ, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":380,"infowindow_disable":false},{"source":"post","title":"Maidstone","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Maidstone<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/maidstone\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"maidstone, kent","location":{"lat":51.270363,"lng":0.522699,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/maidstone\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMs R Williams Local Contact T: 01622 693312\r\n<h3>Address<\/h3>\r\nThe Brenchley, 91 High Street, Maidstone ME14 1SA\r\n<h3>Meetings<\/h3>\r\nMonthly pub lunch at 12.30pm. Contact the Social Secretary for dates[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Maidstone","post_link":"https:\/\/csrf.org.uk\/group\/maidstone\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698912303:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"maidstone, kent, 51.270363, 0.522699, 15, ChIJZ3A0-ALW3kcRzQC0DFJi9aY, Maidstone, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"Maidstone, Kent","%_additional_map_location%":"field_64f2090a4001b"}},"id":379,"infowindow_disable":false},{"source":"post","title":"Mid Sussex","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Mid Sussex<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/mid-sussex\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"burgess hill, west sussex","location":{"lat":50.954469,"lng":-0.128701,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/mid-sussex\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nJohn Taylor Chairman T: 07470 124125\r\nE: <a href=\"mailto:r.taylor40@sky.com\">r.taylor40@sky.com<\/a>\r\nKeith Sullens Vice Chairman T: 01444 233288 E: <a href=\"mailto:sullenskeith@gmail.com\">sullenskeith@gmail.com<\/a>\r\nHelen Fisher Treasurer T: 01444 236841\r\n<h3>Address<\/h3>\r\n<h3>Meetings<\/h3>\r\nWe meet at local cafes\/restaurants in our area for tea &amp; coffee on Third Wednesday of the month at 2.30pm - for more details contact the Chair\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Mid Sussex","post_link":"https:\/\/csrf.org.uk\/group\/mid-sussex\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1707223311:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"burgess hill, west sussex, 50.954469, -0.128701, 14, ChIJJ-HvZRKMdUgR3M1xxBsZY8g, Burgess Hill, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"Burgess Hill, West Sussex","%_additional_map_location%":"field_64f2090a4001b"}},"id":378,"infowindow_disable":false},{"source":"post","title":"Nuneaton","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Nuneaton<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/nuneaton\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Tea & Chat Cafe 2 Chapel Street Nuneaton CV11 5QH","location":{"lat":52.5215112,"lng":-1.4685822,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/nuneaton\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nRachel Homer Secretary T: 024 76 385845\r\nE: <a href=\"mailto:homer351@btinternet.com\">homer351@btinternet.com<\/a>\r\n<h3>Address<\/h3>\r\nTea &amp; Chat Cafe\r\n2 Chapel Street\r\nNuneaton\r\nCV11 5QH\r\n<h3>Meetings<\/h3>\r\nFirst Tuesday of each month at 11am for coffee mornings. All welcome to come along.[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Nuneaton","post_link":"https:\/\/csrf.org.uk\/group\/nuneaton\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698912488:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Tea & Chat Cafe 2 Chapel Street Nuneaton CV11 5QH, 52.5215112, -1.4685822, 14, ChIJQae6fP1Rd0gRpzXnqXcfSKI, 2, Chapel Street, Chapel St, Nuneaton, England, CV11 5QH, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":377,"infowindow_disable":false},{"source":"post","title":"Oswestry","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Oswestry<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/oswestry\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"The Wynnstay Hotel Church Street Oswestry SY11 2SZ","location":{"lat":52.8572148,"lng":-3.0570871,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/oswestry\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMrs R Clarke Chairman T: 01691 623380\r\n<h3>Address<\/h3>\r\nThe Wynnstay Hotel\r\nChurch Street\r\nOswestry\r\nSY11 2SZ\r\n<h3>Meetings<\/h3>\r\nFirst Tuesday of each month at 10.30am\r\n<h3>Events<\/h3>\r\n09 Jan 2024\u00a0 \u00a0AGM &amp; Lunch\r\n06 Feb\u00a0 \u00a0 \u00a0 \u00a0 Talk, 'The Gardens of the North West' - Speaker, Joe Wainwright\r\n05 Mar\u00a0 \u00a0 \u00a0 \u00a0 Talk,'Love Food\/Hate Waste' - Speaker, Joy Blizzard\r\n02 Apr\u00a0 \u00a0 \u00a0 \u00a0 Talk, 'Mexico, A Personal Perspective' - Speaker, Barbara Peart\r\n07 May\u00a0 \u00a0 \u00a0 \u00a0 Talk, 'Eglantyne Jebb' - Speaker, Alison Utting\r\n04 Jun\u00a0 \u00a0 \u00a0 \u00a0 Talk, 'Around the World with a Pack of cards &amp; a White Rabbit' - Speaker, Paul Rushworth[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Oswestry","post_link":"https:\/\/csrf.org.uk\/group\/oswestry\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698912600:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"The Wynnstay Hotel Church Street Oswestry SY11 2SZ, 52.8572148, -3.0570871, 14, ChIJj8maSG2wekgRaU0HgEXLGoE, Church Street, Church St, Oswestry, England, SY11 2SZ, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":376,"infowindow_disable":false},{"source":"post","title":"Princetown","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Princetown<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/princetown\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Prince of Wales Hotel Tavistock Road Princetown PL20 6QF","location":{"lat":50.5446907,"lng":-3.9922565,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/princetown\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMrs S Rose Secretary T: 01822 612114\r\n<h3>Address<\/h3>\r\nPrince of Wales Hotel\r\nTavistock Road\r\nPrincetown\r\nPL20 6QF\r\n<h3>Meetings<\/h3>\r\nFirst Thursday of the month at 12.30pm and other events listed below.\r\n<h3>Events<\/h3>\r\n07 Dec Crocodiles around my Kayak: talk by David Lemon\r\n11 Dec Christmas Practice Lunch to Seco Lounge (tbc)\r\n14 Dec Grand Christmas Draw and Lunch[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Princetown","post_link":"https:\/\/csrf.org.uk\/group\/princetown\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698912818:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Prince of Wales Hotel Tavistock Road Princetown PL20 6QF, 50.5446907, -3.9922565, 14, ChIJKTtGQT_3bEgRJOOk7gOYnG4, Tavistock Road, Tavistock Rd, Yelverton, England, PL20 6QF, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":375,"infowindow_disable":false},{"source":"post","title":"Sidmouth","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Sidmouth<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/sidmouth\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Woodlands Hotel Station Road Sidmouth EX10 8HG","location":{"lat":50.6817588,"lng":-3.2434546,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/sidmouth\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row][vc_column][vc_column_text]<\/p>\r\n<h3>Local Contact(s)<\/h3>\r\n<p>Margaret Adams Chair T: 01395 577622<br \/>\r\nBrenda Harrer Social Secretary T: 01395 519321<br \/>\r\nMark Armstrong Treasurer T: 01395 911094<\/p>\r\n<h3>Address<\/h3>\r\n<p>Woodlands Hotel<br \/>\r\nStation Road<br \/>\r\nSidmouth<br \/>\r\nEX10 8HG<\/p>\r\n<h3>Meetings<\/h3>\r\n<p>Second Wednesday of each month at 10am-11.30am and lunches listed below 12pm for 12.30pm<\/p>\r\n<h3>Events<\/h3>\r\n<p>[\/vc_column_text][\/vc_column][\/vc_row]<\/p>\r\n","post_title":"Sidmouth","post_link":"https:\/\/csrf.org.uk\/group\/sidmouth\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698912793:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Woodlands Hotel Station Road Sidmouth EX10 8HG, 50.6817588, -3.2434546, 14, ChIJvTRB3vucbUgRVodocbRcxiI, Station Road, Station Rd, Sidmouth, England, EX10 8HG, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":374,"infowindow_disable":false},{"source":"post","title":"Sleaford &#038; Ancaster","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Sleaford &#038; Ancaster<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/sleaford-ancaster\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Bristol Bowls Club Boston Road Sleaford NG34 7HH","location":{"lat":52.99730959999999,"lng":-0.4044141000000001,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/sleaford-ancaster\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMike Smith Chairman T: 01526 833273 E: <a href=\"mailto:mjs_consultation@hotmail.com\">mjs_consultation@hotmail.com<\/a>\r\nSue McIntyre Treasurer T: 01400 230308\r\n<h3>Address<\/h3>\r\nBristol Bowls Club\r\nBoston Road\r\nSleaford\r\nNG34 7HH\r\n<h3>Meetings<\/h3>\r\nFirst Thursday of the month from 9.30am-12noon followed by lunch\r\nBristol Bowls Club, Boston Road, Sleaford NG34 7HH\r\n<h3>Events<\/h3>\r\n04 Jan 2024 Seasonal meeting, Raffle &amp; Refreshments followed by New Year lunch\r\n01 Feb Social Meeting, Raffle &amp; Refreshments followed by lunch\r\n07 Mar Social Meeting, Raffle &amp; Refreshments followed by lunch\r\n04 Apr Social Meeting, Raffle &amp; Refreshments followed by lunch[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Sleaford &#038; Ancaster","post_link":"https:\/\/csrf.org.uk\/group\/sleaford-ancaster\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698912951:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Bristol Bowls Club Boston Road Sleaford NG34 7HH, 52.9973096, -0.4044141, 14, ChIJgdHuBCw-eEgRlCGdMA2Nt9Y, 63, Boston Road, Boston Rd, Sleaford, England, NG34 7HH, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":373,"infowindow_disable":false},{"source":"post","title":"Richmond &#038; Twickenham","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Richmond &#038; Twickenham<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/richmond-twickenham\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"twickenham, london","location":{"lat":51.4453043,"lng":-0.3375429,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/richmond-twickenham\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nPhilip Blow Secretary T: 020 8748 7477\r\nE: <a href=\"mailto:p.blow1@btinternet.com\">p.blow1@btinternet.com<\/a>\r\n<h3>Address<\/h3>\r\nVarious venues in and around Twickenham\r\n<h3>Meetings<\/h3>\r\nVarious venues, dates and times. Please contact the Secretary for further details.\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Richmond &#038; Twickenham","post_link":"https:\/\/csrf.org.uk\/group\/richmond-twickenham\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698912720:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"twickenham, london, 51.4453043, -0.3375429, 14, ChIJw8dAspMMdkgR0X5-x2BfouQ, Twickenham, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"Twickenham, London","%_additional_map_location%":"field_64f2090a4001b"}},"id":371,"infowindow_disable":false},{"source":"post","title":"Stubbington","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Stubbington<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/stubbington\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Catholic Church Hall Bells Lane Stubbington Hampshire PO14 2PL","location":{"lat":50.8222995,"lng":-1.2164121,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/stubbington\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nPeter Cornish Treasurer T: 02392 345457\r\n<h3>Address<\/h3>\r\nCatholic Church Hall\r\nBells Lane\r\nStubbington\r\nHampshire\r\nPO14 2PL\r\n<h3>Meetings<\/h3>\r\nSecond Thursday of each month at 2.00pm (except April)\r\n<h3>Events<\/h3>\r\n13 Dec\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0Christmas Meeting with Choir\r\n11 Jan 2024 \u00a0 \u00a0Shedders Strolling Band\r\n08 Feb\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Annual General Meeting\r\n14 Mar\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Meeting with speaker\r\n11 Apr\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Meeting with speaker\r\n09 May\u00a0 \u00a0 \u00a0 \u00a0 Meeting with speaker (tbc)\r\n13 June\u00a0 \u00a0 \u00a0 \u00a0 Meeting with speaker\r\n11 July\u00a0 \u00a0 \u00a0 \u00a0 Meeting with speaker from Elizabeth Foundation\r\n08 Aug\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Meeting with speaker (tbc)\r\n12 Sept\u00a0 \u00a0 \u00a0 \u00a0 Meeting with speaker (tbc)\r\n10 Oct\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Meeting with speaker (tbc)\r\n14 Nov\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Meeting with speaker (tbc)\r\n12 Dec\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Meeting with speaker (tbc)[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Stubbington","post_link":"https:\/\/csrf.org.uk\/group\/stubbington\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698913064:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Catholic Church Hall Bells Lane Stubbington Hampshire PO14 2PL, 50.8222995, -1.2164121, 14, ChIJX2S9IuZldEgR3e6Uirk5tyo, Bells Lane, Bells Ln, Fareham, England, PO14 2BA, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":370,"infowindow_disable":false},{"source":"post","title":"Sutton","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Sutton<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/sutton\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"sutton, south london","location":{"lat":51.3614279,"lng":-0.193961,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/sutton\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nHazel Hoare Social Secretary T: 020 8642 8328\r\n<h3>Address<\/h3>\r\n<h3>Meetings<\/h3>\r\nWe run regular monthly lunch events - for more details\/information, please contact the Social Secretary using the number above\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Sutton","post_link":"https:\/\/csrf.org.uk\/group\/sutton\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698913082:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"sutton, south london, 51.3614279, -0.193961, 14, ChIJ5x88GIDidUgRZu_VRIAwJto, Sutton, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"Sutton, South London","%_additional_map_location%":"field_64f2090a4001b"}},"id":369,"infowindow_disable":false},{"source":"post","title":"Tadley","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Tadley<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/tadley\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Tadley Community Centre Newchurch Road Tadley RG26 4HN","location":{"lat":51.3553558,"lng":-1.1517247,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/tadley\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMr D MacLean Chairman T: 0118 970 1290\r\n<h3>Address<\/h3>\r\nTadley Community Centre\r\nNewchurch Road\r\nTadley\r\nRG26 4HN\r\n<h3>Meetings<\/h3>\r\nFirst Thursday of each month at 1.15pm for 1.45pm\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Tadley","post_link":"https:\/\/csrf.org.uk\/group\/tadley\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698913201:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Tadley Community Centre Newchurch Road Tadley RG26 4HN, 51.3553558, -1.1517247, 14, ChIJZ2IajnChdkgRNxzUOXJVbdE, Newchurch Road, Newchurch Rd, Tadley, England, RG26 4HN, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":367,"infowindow_disable":false},{"source":"post","title":"Tamar\/Tavy (Tavistock)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Tamar\/Tavy (Tavistock)<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/tamar-tavy-tavistock\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"tavistock, devon","location":{"lat":50.5511229,"lng":-4.141654,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/tamar-tavy-tavistock\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nShirley Banks Acting Joint Secretary\/Treasurer T:01752 769586\r\nJoice Reith Acting Joint Secretary\/Chair T: 01822 854368\r\n<h3>Address<\/h3>\r\n<h3>Meetings<\/h3>\r\nThe group meets informally - for details of future events please contact the Secretary and\/or Chair[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Tamar\/Tavy (Tavistock)","post_link":"https:\/\/csrf.org.uk\/group\/tamar-tavy-tavistock\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698913216:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"tavistock, devon, 50.5511229, -4.141654, 14, ChIJMYkG_6xYbEgRpisvxWgkm2w, Tavistock, England, PL19, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"Tavistock, Devon","%_additional_map_location%":"field_64f2090a4001b"}},"id":366,"infowindow_disable":false},{"source":"post","title":"Trowbridge","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Trowbridge<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/trowbridge\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"The Wiltshire Yeoman, Chilmark Road, Trowbridge. BA14 9DD","location":{"lat":51.32312839999999,"lng":-2.2277571,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/trowbridge\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nSue Arnold Secretary T: 01225 761627 E: <a href=\"mailto:suearnoldwfh@blueyonder.co.uk\">suearnoldwfh@blueyonder.co.uk<\/a>\r\n<h3>Meetings<\/h3>\r\n1st and 3rd Wednesdays of the month at The Wiltshire Yeoman, Chilmark Road, Trowbridge. BA14 9DD at 10.30am (Please call before attending the group to confirm the group is meeting)\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Trowbridge","post_link":"https:\/\/csrf.org.uk\/group\/trowbridge\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698913254:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"The Wiltshire Yeoman, Chilmark Road, Trowbridge. BA14 9DD, 51.3231284, -2.2277571, 14, ChIJia68iYjVc0gRVWfW_EpiKf8, Chilmark Road, Chilmark Rd, Trowbridge, England, BA14 9DD, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":365,"infowindow_disable":false},{"source":"post","title":"Westbury","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Westbury<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/westbury\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Paragon Hall Haynes Road Westbury Wiltshire BA13 3HA","location":{"lat":51.256659,"lng":-2.185772,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/westbury\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMr W Clark Chairman T:01373 822892\r\nMr J Harris Social Secretary T:01373 822036\r\n<h3>Address<\/h3>\r\nParagon Hall\r\nHaynes Road\r\nWestbury\r\nWiltshire\r\nBA13 3HA\r\n<h3>Meetings<\/h3>\r\nThird Monday of each month at 1.45pm for 2.00pm (except August and the second Monday of the month in May)\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Westbury","post_link":"https:\/\/csrf.org.uk\/group\/westbury\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698913272:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Paragon Hall Haynes Road Westbury Wiltshire BA13 3HA, 51.256659, -2.185772, 14, ChIJaSA9WVrTc0gRGbKqR1GBYDk, Westbury, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":364,"infowindow_disable":false},{"source":"post","title":"Westbury-on-Trym","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Westbury-on-Trym<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/westbury-on-trym\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"White Lion Pub, Passage Road, Westbury-on-Trym","location":{"lat":51.5057563,"lng":-2.6158433,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/westbury-on-trym\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nTony McKenna Secretary T: 0117 950 2059\r\n<h3>Meetings<\/h3>\r\nPub lunch on the first Thursday of each month (except August) at the White Lion Pub, Passage Road, Westbury-on-Trym (please call Secretary to confirm the lunch is on)\r\n<h3>Events<\/h3>\r\n[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Westbury-on-Trym","post_link":"https:\/\/csrf.org.uk\/group\/westbury-on-trym\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"White Lion Pub, Passage Road, Westbury-on-Trym, 51.5057563, -2.6158433, 14, ChIJA1SUehaScUgRttj7U2To2TI, Passage Road, Passage Rd, Bristol, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_edit_lock%":"1698913442:3","%additional_map_location%":"Westbury On Trym","%_additional_map_location%":"field_64f2090a4001b"}},"id":363,"infowindow_disable":false},{"source":"post","title":"Weston Super Mare","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Weston Super Mare<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/weston-super-mare\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Friends Meeting House High Street Weston-Super-Mare BS23 1JF","location":{"lat":51.3463308,"lng":-2.9781428,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/weston-super-mare\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column width=\"1\/1\"][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nMargaret Cole Chairperson T: 01934 514309\r\nE: <a href=\"mailto:margaretcole@btinternet.com\">margaretcole@btinternet.com<\/a>\r\n<h3>Address<\/h3>\r\nFriends Meeting House\r\nHigh Street\r\nWeston-Super-Mare\r\nBS23 1JF\r\n<h3>Meetings<\/h3>\r\nFirst and third Thursday of the month at 10am as well as events listed below.\r\n<h3>Events<\/h3>\r\n12 Sept Outing: Moreton in Marsh &amp; Bourton on the Water\r\n10 Oct Outing: Worcester\r\n14 Nov Outing: Cardiff\r\n12 Dec Christmas Lunch (tba)[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Weston Super Mare","post_link":"https:\/\/csrf.org.uk\/group\/weston-super-mare\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698913612:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Friends Meeting House High Street Weston-Super-Mare BS23 1JF, 51.3463308, -2.9781428, 14, ChIJSTNom9T4cUgRDZ-kNY-_-n8, 6, High Street, High St, Weston-super-Mare, England, BS23 1JF, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":361,"infowindow_disable":false},{"source":"post","title":"Weymouth","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Weymouth<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/weymouth\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Weymouth Bay Methodist Church 23 Melcombe Avenue Weymouth DT4 7TH","location":{"lat":50.622907,"lng":-2.4481911,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/weymouth\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nGeoff Greenstreet Secretary T: 01305 832432 E: <a href=\"mailto:geoff.marion@btinternet.com\">geoff.marion@btinternet.com<\/a>\r\n<h3>Address<\/h3>\r\nWeymouth Bay Methodist Church\r\n23 Melcombe Avenue\r\nWeymouth\r\nDT4 7TH\r\n<h3>Meetings<\/h3>\r\nFourth Wednesday of the month at 10.30am for an informal coffee morning[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Weymouth","post_link":"https:\/\/csrf.org.uk\/group\/weymouth\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"2","%_edit_lock%":"1698913779:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Weymouth Bay Methodist Church 23 Melcombe Avenue Weymouth DT4 7TH, 50.622907, -2.4481911, 14, ChIJP40AwaL3ckgRbotoOLwdtrI, 32, Melcombe Avenue, Melcombe Ave, Weymouth, England, DT4 7TH, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":""}},"id":360,"infowindow_disable":false},{"source":"post","title":"Worcester Park","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Worcester Park<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/worcester-park\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Old Malden Scout Hall Rear of 411 Malden Road Worcester Park KT4 7NY","location":{"lat":51.3828353,"lng":-0.2495245,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/worcester-park\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nJohn Wright Secretary T: 020 8337 8965\r\nE: <a href=\"mailto:johnandglenisw@gmail.com\">johnandglenisw@gmail.com<\/a>\r\nDavid Staff Treasurer T: 020 8330 2286\r\nE: <a href=\"mailto:davidstaff1@btinternet.com\">davidstaff1@btinternet.com<\/a>\r\n<h3>Address<\/h3>\r\nOld Malden Scout Hall\r\nRear of 411 Malden Road\r\nWorcester Park\r\nKT4 7NY\r\n<h3>Meetings<\/h3>\r\nFirst Monday each month at 2.00 - 4.00pm (if the first Monday is a Bank Holiday, then meeting will be held on the second Monday)\r\n<h3>Events<\/h3>\r\n08 Jan 2024\u00a0 \u00a0Revisiting Olden Days in Surrey.\r\nSpeaker: The Quiz Trail Team\r\n05 Feb\u00a0 \u00a0 \u00a0 \u00a0 Knowing Two British Eccentrics: John Betjeman and James Herriott's Partner Siegfried.\r\nSpeaker: Susan Howe\r\n04 Mar\u00a0 \u00a0 \u00a0 \u00a0 My Life and Times as a Rugby Player and Referee\r\nSpeaker: George Crawford plus his ukelele\r\n08 Apr\u00a0 \u00a0 \u00a0 \u00a0 The Life and Times of Admiral Nelson\r\nSpeaker: Roy Buchanan\r\n13 May\u00a0 \u00a0 \u00a0 \u00a0 Secrets, Scandal and Salacious Gossip of the Royal Court, 1660 to 1830\u00a0 \u00a0 Speaker: Sarah Slater[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Worcester Park","post_link":"https:\/\/csrf.org.uk\/group\/worcester-park\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698914207:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Old Malden Scout Hall Rear of 411 Malden Road Worcester Park KT4 7NY, 51.3828353, -0.2495245, 14, EjJSZWFyIG9mLCA0MTEgTWFsZGVuIFJkLCBXb3JjZXN0ZXIgUGFyayBLVDQgN05ZLCBVSyIjGiEKFgoUChIJK0BJJaQJdkgRHXxYmg9WZ6QSB1JlYXIgb2Y, 411, Malden Road, Malden Rd, Worcester Park, England, KT4 7NY, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":359,"infowindow_disable":false},{"source":"post","title":"Yate &#038; District","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Yate &#038; District<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/yate-district\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Yate Parish Hall Station Road Yate BS37 4PQ","location":{"lat":51.5404472,"lng":-2.4223034,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/yate-district\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nVal Gannaway Group Leader T: 01454 317968\r\n<h3>Address<\/h3>\r\nYate Parish Hall\r\nStation Road\r\nYate\r\nBS37 4PQ\r\n<h3>Meetings<\/h3>\r\nFourth Tuesday of the month from 1.30-4.30pm (except December).\r\n<h3>Events<\/h3>\r\n12 Dec Christmas Party with the Golden Tones, 11.30am-3.30am[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Yate &#038; District","post_link":"https:\/\/csrf.org.uk\/group\/yate-district\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698919752:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"Yate Parish Hall Station Road Yate BS37 4PQ, 51.5404472, -2.4223034, 14, ChIJMU1qAWmbcUgRLCrsJ0B_aNg, Bristol, England, BS37 4PQ, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":358,"infowindow_disable":false},{"source":"post","title":"York &#038; District","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">York &#038; District<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/york-district\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"york","location":{"lat":53.9614205,"lng":-1.0739108,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/york-district\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nLocal Group Contact: Lisa Gill Tel: 0208 225 8479, Mob: 07917 067 860 or email: lisa.gill@defra.gov.uk\r\n<h3>Address<\/h3>\r\nVarious venues in York - contact for more details\r\n<h3>Meetings<\/h3>\r\nFriendship Lunch at 12.30pm on the Last Tuesday of the month\r\n<h3>Events<\/h3>\r\nDec Christmas Lunch (tba)[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"York &#038; District","post_link":"https:\/\/csrf.org.uk\/group\/york-district\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698914268:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%group_location%":"york, 53.9614205, -1.0739108, 14, ChIJ8WWY4UDDeEgR0eRUiomrdEc, York, England, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":247,"infowindow_disable":false},{"source":"post","title":"Worcester","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <!---->\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n            <div class=\"fc-item-meta fc-item-secondary-text-color fc-item-top-space fc-text-center\"><\/div>\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-text-center\">Worcester<\/div>\r\n<div class=\"post-link\"><a class=\"w-btn us-btn-style_1\" href=\"https:\/\/csrf.org.uk\/group\/worcester\/\">View Group<\/a><\/div>\r\n           <!-- <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div> -->\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Perdiswell Young Peoples' Leisure Club Droitwich Road (opposite Checketts Lane) Worcester WR3 7SN","location":{"lat":52.2152804,"lng":-2.2190457,"onclick_action":"marker","redirect_permalink":"https:\/\/csrf.org.uk\/group\/worcester\/","zoom":5,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>Local Contact(s)<\/h3>\r\nHelen Connelly Chair T: 01905 830451\r\n<h3>Address<\/h3>\r\nPerdiswell Young Peoples' Leisure Club\r\nDroitwich Road (opposite Checketts Lane)\r\nWorcester\r\nWR3 7SN\r\n<h3>Meetings<\/h3>\r\nSecond Wednesday of the month at 1pm (except August)\r\n<h3>Events<\/h3>\r\n10 Jan 2024 \u00a0 \u00a0New Year Buffet\r\n14 Feb\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Tea, Biscuits and a chat\r\n13 Mar\u00a0 \u00a0 \u00a0 \u00a0 \u00a0AGM\r\n10 Apr\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Tea, Biscuits and a chat\r\n08 May\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Tea, Biscuits and a chat\r\n12 Jun\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Tea, Biscuits and a chat\r\n10 Jul\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Midsummer Buffet Lunch\r\n14 Aug\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Tea, Biscuits and a chat\r\n11 Sept\u00a0 \u00a0 \u00a0 \u00a0 Tea, Biscuits and a chat\r\n09 Oct\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Tea, Biscuits and a chat\r\n13 Nov\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Tea, Biscuits and a chat\r\n11 Dec\u00a0 \u00a0 \u00a0 \u00a0 \u00a0Christmas Buffet Lunch[\/vc_column_text][\/vc_column][\/vc_row]","post_title":"Worcester","post_link":"https:\/\/csrf.org.uk\/group\/worcester\/","post_featured_image":"","post_categories":"","post_tags":"","%_edit_last%":"3","%_edit_lock%":"1698914010:3","%us_tile_link%":"%7B%22url%22%3A%22%22%7D","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"","%_wpgmp_metabox_longitude%":"","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_vc_js_status%":"true","%group_location%":"Perdiswell Young Peoples' Leisure Club Droitwich Road (opposite Checketts Lane) Worcester WR3 7SN, 52.2152804, -2.2190457, 14, ChIJ6eKzDDfxcEgRxQUzC7jX1QA, Worcester, England, WR3 7SN, United Kingdom, GB","%_group_location%":"field_64d0fe03b6780","%additional_map_location%":"","%_additional_map_location%":"field_64f2090a4001b"}},"id":61,"infowindow_disable":false}],"listing":{"listing_header":"Locations Listing","display_search_form":true,"search_field_autosuggest":false,"display_category_filter":false,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing1","tabs_container":".location_listing1","hide_locations":false,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":"100"},"list_grid":"wpgmp_listing_grid","listing_placeholder":"<div class=\"fc-item-box fc-component-2 wpgmp_locations style=\"margin: 20px!important;\">\r\n    <div class=\"fc-component-block\">\r\n        <div class=\"fc-component-content\">\r\n            <ul>\r\n               <!-- <li class=\"fc-item-featured fc-component-thumb fc-item-top_space\">\r\n                    <div class=\"fc-featured-hoverdiv\">\r\n                        <div class=\"fc-featured-hoverinner \"><a {onclick_action}=\"\" class=\"map\"><\/a><\/div>\r\n                        {marker_image}\r\n                    <\/div>\r\n                <\/li>-->\r\n\r\n                <li class=\"fc-component-text\">\r\n                    <div class=\"fc-itemcontent-padding\">\r\n                        <div class=\"fc-item-title fc-item-primary-text-color center\"><h3>{marker_title}<\/h3><\/div>\r\n                        <div class=\"fc-item-content fc-item-body-text-color\">\r\n                            {marker_message}\r\n                        <\/div>\r\n                        <a href=\"{post_link}\" {onclick_action}=\"\" class=\"w-btn us-btn-style_1 align-left\">View Group<\/a>\r\n                    <\/div>\r\n                <\/li>\r\n            <\/ul>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","list_item_skin":{"name":"aare","type":"item","sourcecode":"&lt;div class=&quot;fc-item-box fc-component-2 wpgmp_locations style=&quot;margin: 20px!important;&quot;&gt;\r\n    &lt;div class=&quot;fc-component-block&quot;&gt;\r\n        &lt;div class=&quot;fc-component-content&quot;&gt;\r\n            &lt;ul&gt;\r\n               &lt;!-- &lt;li class=&quot;fc-item-featured fc-component-thumb fc-item-top_space&quot;&gt;\r\n                    &lt;div class=&quot;fc-featured-hoverdiv&quot;&gt;\r\n                        &lt;div class=&quot;fc-featured-hoverinner &quot;&gt;&lt;a {onclick_action}=&quot;&quot; class=&quot;map&quot;&gt;&lt;\/a&gt;&lt;\/div&gt;\r\n                        {marker_image}\r\n                    &lt;\/div&gt;\r\n                &lt;\/li&gt;--&gt;\r\n\r\n                &lt;li class=&quot;fc-component-text&quot;&gt;\r\n                    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n                        &lt;div class=&quot;fc-item-title fc-item-primary-text-color center&quot;&gt;&lt;h3&gt;{marker_title}&lt;\/h3&gt;&lt;\/div&gt;\r\n                        &lt;div class=&quot;fc-item-content fc-item-body-text-color&quot;&gt;\r\n                            {marker_message}\r\n                        &lt;\/div&gt;\r\n                        &lt;a href=&quot;{post_link}&quot; {onclick_action}=&quot;&quot; class=&quot;w-btn us-btn-style_1 align-left&quot;&gt;View Group&lt;\/a&gt;\r\n                    &lt;\/div&gt;\r\n                &lt;\/li&gt;\r\n            &lt;\/ul&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;"}},"map_property":{"map_id":"1","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"}}